Java基础学习总结(17)——线程

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

一、线程的基本概念

  

线程理解:线程是一个程序里面不同的执行路径

  每一个分支都叫做一个线程,main()叫做主分支,也叫主线程。

  程只是一个静态的概念,机器上的一个.class文件,机器上的一个.exe文件,这个叫做一个进程。程序的执行过程都是这样的:首先把程序的代码放到内存的代码区里面,代码放到代码区后并没有马上开始执行,但这时候说明了一个进程准备开始,进程已经产生了,但还没有开始执行,这就是进程,所以进程其实是一个静态的概念,它本身就不能动。平常所说的进程的执行指的是进程里面主线程开始执行了,也就是main()方法开始执行了。进程是一个静态的概念,在我们机器里面实际上运行的都是线程。

  Windows操作系统是支持多线程的,它可以同时执行很多个线程,也支持多进程,因此Windows操作系统是支持多线程多进程的操作系统。LinuxUinux也是支持多线程和多进程的操作系统。DOS就不是支持多线程和多进程了,它只支持单进程,在同一个时间点只能有一个进程在执行,这就叫单线程

  CPU难道真的很神通广大,能够同时执行那么多程序吗?不是的,CPU的执行是这样的:CPU的速度很快,一秒钟可以算好几亿次,因此CPU把自己的时间分成一个个小时间片,我这个时间片执行你一会,下一个时间片执行他一会,再下一个时间片又执行其他人一会,虽然有几十个线程,但一样可以在很短的时间内把他们通通都执行一遍,但对我们人来说,CPU的执行速度太快了,因此看起来就像是在同时执行一样,但实际上在一个时间点上,CPU只有一个线程在运行。

学习线程首先要理清楚三个概念:

  1. 进程:进程是一个静态的概念
  2. 线程:一个进程里面有一个主线程叫main()方法,是一个程序里面的,一个进程里面不同的执行路径。
  3. 在同一个时间点上,一个CPU只能支持一个线程在执行。因为CPU运行的速度很快,因此我们看起来的感觉就像是多线程一样。

  什么才是真正的多线程?如果你的机器是双CPU,或者是双核,这确确实实是多线程。

二、线程的创建和启动

  

  在JAVA里面,JAVA的线程是通过java.lang.Thread类来实现的,每一个Thread对象代表一个新的线程。创建一个新线程出来有两种方法:第一个是从Thread类继承,另一个是实现接口runnableVM启动时会有一个由主方法(public static void main())所定义的线程,这个线程叫主线程。可以通过创建Thread的实例来创建新的线程。你只要new一个Thread对象,一个新的线程也就出现了。每个线程都是通过某个特定的Thread对象所对应的方法run()来完成其操作的,方法run()称为线程体。

范例1:使用实现Runnable接口创建和启动新线程

开辟一个新的线程来调用run方法

复制代码
 1 package cn.galc.test;
 2 
 3 public class TestThread1{
 4     public static void main(String args[]){
 5         Runner1 r1 = new Runner1();//这里new了一个线程类的对象出来
 6         //r1.run();//这个称为方法调用,方法调用的执行是等run()方法执行完之后才会继续执行main()方法
 7         Thread t = new Thread(r1);//要启动一个新的线程就必须new一个Thread对象出来
 8         //这里使用的是Thread(Runnable target) 这构造方法
 9         t.start();//启动新开辟的线程,新线程执行的是run()方法,新线程与主线程会一起并行执行
10         for(int i=0;i<10;i++){
11             System.out.println("maintheod:"+i);
12         }
13     }
14 }
15 /*定义一个类用来实现Runnable接口,实现Runnable接口就表示这个类是一个线程类*/
16 class Runner1 implements Runnable{
17     public void run(){
18         for(int i=0;i<10;i++){
19             System.out.println("Runner1:"+i);
20         }
21     }
22 }
复制代码

多线程程序执行的过程如下所示:

 

不开辟新线程直接调用run方法

 

运行结果如下:

 范例2:继承Thread类,并重写其run()方法创建和启动新的线程

复制代码
 1 package cn.galc.test;
 2 
 3 /*线程创建与启动的第二种方法:定义Thread的子类并实现run()方法*/
 4 public class TestThread2{
 5     public static void main(String args[]){
 6         Runner2 r2 = new Runner2();
 7         r2.start();//调用start()方法启动新开辟的线程
 8         for(int i=0;i<=10;i++){
 9             System.out.println("mainMethod:"+i);
10         }
11     }
12 }
13 /*Runner2类从Thread类继承
14 通过实例化Runner2类的一个对象就可以开辟一个新的线程
15 调用从Thread类继承来的start()方法就可以启动新开辟的线程*/
16 class Runner2 extends Thread{
17     public void run(){//重写run()方法的实现
18         for(int i=0;i<=10;i++){
19             System.out.println("Runner2:"+i);
20         }
21     }
22 }
复制代码

  使用实现Runnable接口和继承Thread类这两种开辟新线程的方法的选择应该优先选择实现Runnable接口这种方式去开辟一个新的线程。因为接口的实现可以实现多个,而类的继承只能是单继承。因此在开辟新线程时能够使用Runnable接口就尽量不要使用从Thread类继承的方式来开辟新的线程。

三、线程状态转换

  

3.1.线程控制的基本方法

  

3.2. sleep/join/yield方法介绍

  

sleep方法的应用范例:

复制代码
 1 package cn.galc.test;
 2 
 3 import java.util.*;
 4 
 5 public class TestThread3 {
 6     public static void main(String args[]){
 7         MyThread thread = new MyThread();
 8         thread.start();//调用start()方法启动新开辟的线程
 9         try {
10             /*Thread.sleep(10000);
11             sleep()方法是在Thread类里面声明的一个静态方法,因此可以使用Thread.sleep()的格式进行调用
12             */
13             /*MyThread.sleep(10000);
14             MyThread类继承了Thread类,自然也继承了sleep()方法,所以也可以使用MyThread.sleep()的格式进行调用
15             */
16             /*静态方法的调用可以直接使用“类名.静态方法名”
17               或者“对象的引用.静态方法名”的方式来调用*/
18             MyThread.sleep(10000);
19             System.out.println("主线程睡眠了10秒种后再次启动了");
20             //在main()方法里面调用另外一个类的静态方法时,需要使用“静态方法所在的类.静态方法名”这种方式来调用
21             /*
22             所以这里是让主线程睡眠10秒种
23             在哪个线程里面调用了sleep()方法就让哪个线程睡眠,所以现在是主线程睡眠了。
24             */
25         } catch (InterruptedException e) {
26             e.printStackTrace();
27         }
28         //thread.interrupt();//使用interrupt()方法去结束掉一个线程的执行并不是一个很好的做法
29         thread.flag=false;//改变循环条件,结束死循环
30         /**
31          * 当发生InterruptedException时,直接把循环的条件设置为false即可退出死循环,
32          * 继而结束掉子线程的执行,这是一种比较好的结束子线程的做法
33          */
34         /**
35          * 调用interrupt()方法把正在运行的线程打断
36         相当于是主线程一盆凉水泼上去把正在执行分线程打断了
37         分线程被打断之后就会抛InterruptedException异常,这样就会执行return语句返回,结束掉线程的执行
38         所以这里的分线程在执行完10秒钟之后就结束掉了线程的执行
39          */
40     }
41 }
42 
43 class MyThread extends Thread {
44     boolean flag = true;// 定义一个标记,用来控制循环的条件
45 
46     public void run() {
47         /*
48          * 注意:这里不能在run()方法的后面直接写throw Exception来抛异常, 
49          * 因为现在是要重写从Thread类继承而来的run()方法,重写方法不能抛出比被重写的方法的不同的异常。
50          *  所以这里只能写try……catch()来捕获异常
51          */
52         while (flag) {
53             System.out.println("==========" + new Date().toLocaleString() + "===========");
54             try {
55                 /*
56                  * 静态方法的调用格式一般为“类名.方法名”的格式去调用 在本类中声明的静态方法时调用时直接写静态方法名即可。 当然使用“类名.方法名”的格式去调用也是没有错的
57                  */
58                 // MyThread.sleep(1000);//使用“类名.方法名”的格式去调用属于本类的静态方法
59                 sleep(1000);//睡眠的时如果被打断就会抛出InterruptedException异常
60                 // 这里是让这个新开辟的线程每隔一秒睡眠一次,然后睡眠一秒钟后再次启动该线程
61                 // 这里在一个死循环里面每隔一秒启动一次线程,每个一秒打印出当前的系统时间
62             } catch (InterruptedException e) {
63                 /*
64                  * 睡眠的时一盘冷水泼过来就有可能会打断睡眠 
65                  * 因此让正在运行线程被一些意外的原因中断的时候有可能会抛被打扰中断(InterruptedException)的异常
66                  */
67                 return;
68                 // 线程被中断后就返回,相当于是结束线程
69             }
70         }
71     }
72 }
复制代码

运行结果:

 join方法的使用范例:

复制代码
 1 package cn.galc.test;
 2 
 3 public class TestThread4 {
 4     public static void main(String args[]) {
 5         MyThread2 thread2 = new MyThread2("mythread");
 6         // 在创建一个新的线程对象的同时给这个线程对象命名为mythread
 7         thread2.start();// 启动线程
 8         try {
 9             thread2.join();// 调用join()方法合并线程,将子线程mythread合并到主线程里面
10             // 合并线程后,程序的执行的过程就相当于是方法的调用的执行过程
11         } catch (InterruptedException e) {
12             e.printStackTrace();
13         }
14         for (int i = 0; i <= 5; i++) {
15             System.out.println("I am main Thread");
16         }
17     }
18 }
19 
20 class MyThread2 extends Thread {
21     MyThread2(String s) {
22         super(s);
23         /*
24          * 使用super关键字调用父类的构造方法 
25          * 父类Thread的其中一个构造方法:“public Thread(String name)” 
26          * 通过这样的构造方法可以给新开辟的线程命名,便于管理线程
27          */
28     }
29 
30     public void run() {
31         for (int i = 1; i <= 5; i++) {
32             System.out.println("I am a\t" + getName());
33             // 使用父类Thread里面定义的
34             //public final String getName(),Returns this thread's name.
35             try {
36                 sleep(1000);// 让子线程每执行一次就睡眠1秒钟
37             } catch (InterruptedException e) {
38                 return;
39             }
40         }
41     }
42 }
复制代码

运行结果:

yield方法的使用范例:

复制代码
 1 package cn.galc.test;
 2 
 3 public class TestThread5 {
 4     public static void main(String args[]) {
 5         MyThread3 t1 = new MyThread3("t1");
 6         /* 同时开辟了两条子线程t1和t2,t1和t2执行的都是run()方法 */
 7         /* 这个程序的执行过程中总共有3个线程在并行执行,分别为子线程t1和t2以及主线程 */
 8         MyThread3 t2 = new MyThread3("t2");
 9         t1.start();// 启动子线程t1
10         t2.start();// 启动子线程t2
11         for (int i = 0; i <= 5; i++) {
12             System.out.println("I am main Thread");
13         }
14     }
15 }
16 
17 class MyThread3 extends Thread {
18     MyThread3(String s) {
19         super(s);
20     }
21 
22     public void run() {
23         for (int i = 1; i <= 5; i++) {
24             System.out.println(getName() + ":" + i);
25             if (i % 2 == 0) {
26                 yield();// 当执行到i能被2整除时当前执行的线程就让出来让另一个在执行run()方法的线程来优先执行
27                 /*
28                  * 在程序的运行的过程中可以看到,
29                  * 线程t1执行到(i%2==0)次时就会让出线程让t2线程来优先执行 
30                  * 而线程t2执行到(i%2==0)次时也会让出线程给t1线程优先执行
31                  */
32             }
33         }
34     }
35 }
复制代码

运行结果如下:

 

一、线程的优先级别

  

线程优先级别的使用范例:

复制代码
 1 package cn.galc.test;
 2 
 3 public class TestThread6 {
 4     public static void main(String args[]) {
 5         MyThread4 t4 = new MyThread4();
 6         MyThread5 t5 = new MyThread5();
 7         Thread t1 = new Thread(t4);
 8         Thread t2 = new Thread(t5);
 9         t1.setPriority(Thread.NORM_PRIORITY + 3);// 使用setPriority()方法设置线程的优先级别,这里把t1线程的优先级别进行设置
10         /*
11          * 把线程t1的优先级(priority)在正常优先级(NORM_PRIORITY)的基础上再提高3级 
12          * 这样t1的执行一次的时间就会比t2的多很多     
13          * 默认情况下NORM_PRIORITY的值为5
14          */
15         t1.start();
16         t2.start();
17         System.out.println("t1线程的优先级是:" + t1.getPriority());
18         // 使用getPriority()方法取得线程的优先级别,打印出t1的优先级别为8
19     }
20 }
21 
22 class MyThread4 implements Runnable {
23     public void run() {
24         for (int i = 0; i <= 1000; i++) {
25             System.out.println("T1:" + i);
26         }
27     }
28 }
29 
30 class MyThread5 implements Runnable {
31     public void run() {
32         for (int i = 0; i <= 1000; i++) {
33             System.out.println("===============T2:" + i);
34         }
35     }
36 }
复制代码

  run()方法一结束,线程也就结束了。

二、线程同步

  

synchronized关键字的使用范例:

复制代码
 1 package cn.galc.test;
 2 
 3 public class TestSync implements Runnable {
 4     Timer timer = new Timer();
 5 
 6     public static void main(String args[]) {
 7         TestSync test = new TestSync();
 8         Thread t1 = new Thread(test);
 9         Thread t2 = new Thread(test);
10         t1.setName("t1");// 设置t1线程的名字
11         t2.setName("t2");// 设置t2线程的名字
12         t1.start();
13         t2.start();
14     }
15 
16     public void run() {
17         timer.add(Thread.currentThread().getName());
18     }
19 }
20 
21 class Timer {
22     private static int num = 0;
23 
24     public/* synchronized */void add(String name) {// 在声明方法时加入synchronized时表示在执行这个方法的过程之中当前对象被锁定
25         synchronized (this) {
26             /*
27              * 使用synchronized(this)来锁定当前对象,这样就不会再出现两个不同的线程同时访问同一个对象资源的问题了 只有当一个线程访问结束后才会轮到下一个线程来访问
28              */
29             num++;
30             try {
31                 Thread.sleep(1);
32             } catch (InterruptedException e) {
33                 e.printStackTrace();
34             }
35             System.out.println(name + ":你是第" + num + "个使用timer的线程");
36         }
37     }
38 }
复制代码

线程死锁的问题:

复制代码
 1 package cn.galc.test;
 2 
 3 /*这个小程序模拟的是线程死锁的问题*/
 4 public class TestDeadLock implements Runnable {
 5     public int flag = 1;
 6     static Object o1 = new Object(), o2 = new Object();
 7 
 8     public void run() {
 9         System.out.println(Thread.currentThread().getName() + "的flag=" + flag);
10         /*
11          * 运行程序后发现程序执行到这里打印出flag以后就再也不往下执行后面的if语句了 
12          * 程序也就死在了这里,既不往下执行也不退出
13          */
14 
15         /* 这是flag=1这个线程 */
16         if (flag == 1) {
17             synchronized (o1) {
18                 /* 使用synchronized关键字把对象01锁定了 */
19                 try {
20                     Thread.sleep(500);
21                 } catch (InterruptedException e) {
22                     e.printStackTrace();
23                 }
24                 synchronized (o2) {
25                     /*
26                      * 前面已经锁住了对象o1,只要再能锁住o2,那么就能执行打印出1的操作了 
27                      * 可是这里无法锁定对象o2,因为在另外一个flag=0这个线程里面已经把对象o1给锁住了 
28                      * 尽管锁住o2这个对象的线程会每隔500毫秒睡眠一次,可是在睡眠的时候仍然是锁住o2不放的
29                      */
30                     System.out.println("1");
31                 }
32             }
33         }
34         /*
35          * 这里的两个if语句都将无法执行,因为已经造成了线程死锁的问题 
36          * flag=1这个线程在等待flag=0这个线程把对象o2的锁解开, 
37          * 而flag=0这个线程也在等待flag=1这个线程把对象o1的锁解开 
38          * 然而这两个线程都不愿意解开锁住的对象,所以就造成了线程死锁的问题
39          */
40 
41         /* 这是flag=0这个线程 */
42         if (flag == 0) {
43             synchronized (o2) {
44                 /* 这里先使用synchronized锁住对象o2 */
45                 try {
46                     Thread.sleep(500);
47                 } catch (InterruptedException e) {
48                     e.printStackTrace();
49                 }
50                 synchronized (o1) {
51                     /*
52                      * 前面已经锁住了对象o2,只要再能锁住o1,那么就能执行打印出0的操作了 可是这里无法锁定对象o1,因为在另外一个flag=1这个线程里面已经把对象o1给锁住了 尽管锁住o1这个对象的线程会每隔500毫秒睡眠一次,可是在睡眠的时候仍然是锁住o1不放的
53                      */
54                     System.out.println("0");
55                 }
56             }
57         }
58     }
59 
60     public static void main(String args[]) {
61         TestDeadLock td1 = new TestDeadLock();
62         TestDeadLock td2 = new TestDeadLock();
63         td1.flag = 1;
64         td2.flag = 0;
65         Thread t1 = new Thread(td1);
66         Thread t2 = new Thread(td2);
67         t1.setName("线程td1");
68         t2.setName("线程td2");
69         t1.start();
70         t2.start();
71     }
72 }
复制代码

  解决线程死锁的问题最好只锁定一个对象,不要同时锁定两个对象

生产者消费者问题:

复制代码
 1 package cn.galc.test;
 2 
 3 /*    范例名称:生产者--消费者问题
 4  *     源文件名称:ProducerConsumer.java
 5  *    要  点:
 6  *        1. 共享数据的不一致性/临界资源的保护
 7  *        2. Java对象锁的概念
 8  *        3. synchronized关键字/wait()及notify()方法
 9  */
10 
11 public class ProducerConsumer {
12     public static void main(String args[]){
13             SyncStack stack = new SyncStack();
14             Runnable p=new Producer(stack);
15             Runnable c = new Consumer(stack);
16             Thread p1 = new Thread(p);
17             Thread c1 = new Thread(c);
18             
19             p1.start();
20             c1.start();
21     }
22 }
23 
24 
25 class SyncStack{  //支持多线程同步操作的堆栈的实现
26     private int index = 0;
27     private char []data = new char[6];    
28     public synchronized void push(char c){
29         if(index == data.length){
30         try{
31                 this.wait();
32         }catch(InterruptedException e){}
33         }
34         this.notify();
35         data[index] = c;
36         index++;
37     }
38     public synchronized char pop(){
39         if(index ==0){
40             try{
41                 this.wait();
42             }catch(InterruptedException e){}
43         }
44         this.notify();
45         index--;
46         return data[index];
47     }
48 }
49 
50 
51 class  Producer implements Runnable{
52     SyncStack stack;    
53     public Producer(SyncStack s){
54         stack = s;
55     }
56     public void run(){
57         for(int i=0; i<20; i++){
58             char c =(char)(Math.random()*26+'A');
59             stack.push(c);
60             System.out.println("produced:"+c);
61             try{                                    
62                 Thread.sleep((int)(Math.random()*1000)); 
63             }catch(InterruptedException e){
64             }
65         }
66     }
67 }
68 
69 
70 class Consumer implements Runnable{
71     SyncStack stack;    
72     public Consumer(SyncStack s){
73         stack = s;
74     }
75     public void run(){
76         for(int i=0;i<20;i++){
77             char c = stack.pop();
78             System.out.println("消费:"+c);
79             try{                                       
80                 Thread.sleep((int)(Math.random()*1000));
81             }catch(InterruptedException e){
82             }
83         }
84     }
85 }
复制代码

转载于:https://my.oschina.net/zhanghaiyang/blog/594668

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/251619.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

(转)MySQL自带的性能压力测试工具mysqlslap详解

mysqlslap 是 Mysql 自带的压力测试工具&#xff0c;可以模拟出大量客户端同时操作数据库的情况&#xff0c;通过结果信息来了解数据库的性能状况 mysqlslap 的一个主要工作场景就是对数据库服务器做基准测试 例如我们拿到了一台服务器&#xff0c;准备做为数据库服务器&#x…

node.js HelloWord

创建 server.js var http require("http"); http.createServer(function(req,res){ //设置请求头的编码格式 res.writeHead(200,{Content-Type:text/html;charsetutf-8}); //设置网页的编码格式&#xff08;防止中文乱码&#xff09; res.write("<head>&…

架构师不可不知的十大可扩展架构

2019独角兽企业重金招聘Python工程师标准>>> 可扩展性正是如今软件设计领域最值得优先考虑的要素。然而&#xff0c;计算机科学家们还无法了解一套单独的架构如何才能扩展至各类应用环境当中。相反&#xff0c;我们在数量繁多的方案中所设计出的可扩展性架构&#x…

Winform开发框架中工作流模块的业务表单开发

在我们开发工作流的时候&#xff0c;往往需要设计到具体业务表单信息的编辑&#xff0c;有些是采用动态编辑的&#xff0c;有些则是在开发过程中处理的&#xff0c;各有各的优点&#xff0c;动态编辑的则方便维护各种各样的表单&#xff0c;但是数据的绑定及处理则比较麻烦&…

RabbitMQ学习总结(2)——安装、配置与监控

2019独角兽企业重金招聘Python工程师标准>>> 一、安装 1、安装Erlang 1&#xff09;系统编译环境&#xff08;这里采用linux/unix 环境&#xff09; ① 安装环境 虚拟机&#xff1a;VMware Workstation 10.0.1 build Linux系统&#xff1a;CentOS6.5 rabbitMQ官网下…

CODE[VS] 3411 洪水

题目描述 Description小浣熊松松和朋友到野外露营&#xff0c;没想到遇上了&pi;年一次的大洪水&#xff0c;好在松松是一只爱观察的小浣熊&#xff0c;他发现露营地的地形和洪水有如下性质&#xff1a; ①露营地可以被看做是一个N*M的矩形方阵&#xff0c;其中左上角坐标为…

Solr管理页面 上

DashBoard&#xff08;仪表盘&#xff09;Logging&#xff08;日志&#xff09;Core Admin&#xff08;Core管理&#xff09;在Solr中&#xff0c;每一个Core&#xff0c;代表一个索引库&#xff0c;里面包含索引数据及其配置信息。Solr中可以拥有多个Core&#xff0c;也就同时…

GRPC协议的相关原理

GRPC的Client与Server&#xff0c;均通过Netty Channel作为数据通信&#xff0c;序列化、反序列化则使用Protobuf&#xff0c;每个请求都将被封装成HTTP2的Stream&#xff0c;在整个生命周期中&#xff0c;客户端Channel应该保持长连接&#xff0c;而不是每次调用重新创建Chann…

Echarts --- 各个省份的坐标

纯手打…效果如下 1.新疆: [86.61 , 40.79] 2.西藏:[89.13 , 30.66] 3.黑龙江:[128.34 , 47.05] 4.吉林:[126.32 , 43.38] 5.辽宁:[123.42 , 41.29] 6.内蒙古:[112.17 , 42.81] 7.北京:[116.40 , 40.40 ] 8.宁夏:[106.27 , 36.76] 9.山西:[111.95,37.65] 10.河北:[115.21 , 38.…

C++标准输入流、输出流以及文件流

1、流的控制 iomanip 在使用格式化I/O时应包含此头文件。 stdiostream 用于混合使用C和C 的I/O机制时&#xff0c;例如想将C程序转变为C程序 2、类继承关系 ios是抽象基类&#xff0c;由它派生出istream类和ostream类&#xff0c; iostream类支持输入输出操作&…

Hadoop学习笔记—8.Combiner与自定义Combiner

一、Combiner的出现背景 1.1 回顾Map阶段五大步骤 在第四篇博文《初识MapReduce》中&#xff0c;我们认识了MapReduce的八大步凑&#xff0c;其中在Map阶段总共五个步骤&#xff0c;如下图所示&#xff1a; 其中&#xff0c;step1.5是一个可选步骤&#xff0c;它就是我们今天需…

css --- 行内框和内容区

css规定font-size的大小实际上是字体的高度 可以将内容区理解为font-size的大小. 行内高可以理解为 ( (line-height) - (font-size) ) /2 然后再font-size 的上下加上前面的值 看下面的例子 <p style"font-size:12px;line-height:12px;">this is text, <em&…

DotNetTextBox V3.0 所见即所得编辑器控件 For Asp.Net2.0(ver 3.0.7Beta) 增加多语言!

英文名&#xff1a;DotNetTextBox V3.0 WYSWYG Web Control For Asp.Net2.0 中文名&#xff1a;DotNetTextBox V3.0 所见即所得编辑器控件 For Asp.Net2.0 类型: 免费控件(保留版权) 作者: 小宝.NET 2.0(Terry Deng) 主页&#xff1a;http://www.aspxcn.com.cn 控件演示页面: h…

css --- 浮动元素与 块框/行内框重叠时的细节

块框,可以认为是块级元素(如div、h1)的内容区 内边距 行内框可以认为是行内元素(如span)的内容区 内边距 当 块级框/行内框 和一个浮动元素重叠时&#xff0c;行内框的边框、背景和内容都在幅度元素之上&#xff0c;块级框的边框和背景都在浮动元素的下面&#xff0c;但内容在…

npm --- 包的发布与导入

安装好NODE后,下面演示如何编写一个包,并将其发布到NPM仓库中,最后通过NPM安装回本地. 以下例子是在windows*64环境下运行的. 1.编写模块 exports.sayHello function(){return Hello World; }将上述代码保存在hello.js中 2.初始化包描述文件: 使用npm init指令,快速生成包…

XPath 的使用

XPath 的使用 XPath&#xff0c;全称XML Path Language&#xff0c;即XML路径语言&#xff0c;它是一门在XML文档中查找信息的语言&#xff0c;最初用于搜寻XML文档&#xff0c;但是也同样适用于HTML文档的搜索。前面我们在解析或抽取网页信息时&#xff0c;使用的是正则表达式…

WinCC归档数据报表控件

1、背景 WinCC实现报表历来是老大难&#xff0c;自带的报表功能不好使&#xff0c;又没有好用的第三方控件。虽然网上也有很多实现报表的方法&#xff0c;但是毫无例外的要求使用者具有脚本编程功底&#xff0c;HwDataReport的出现将终结这一现象。您无需一行脚本即可完成…

第三次实验报告

项目一 项目分析 本项目目的就是考察我们调用searching类和sorting类中的方法&#xff0c;通过提交测试用例设计情况&#xff08;正常&#xff0c;异常&#xff0c;边界&#xff0c;正序&#xff0c;逆序&#xff09;确保类的可行性 代码截图 排序截图 运行截图 项目二 代码截…

Node --- 构建一个HTTP服务

代码如下: var http require(http); http.createServer(function (req, res){res.writeHead(200,{Content-Type: text/plain});res.end(Hello World\n); }).listen(1337, 127.0.0.1); console.log(Server running at http://127.0.0.1:1337);运行如下&#xff1a; 详情见《深…

DDR3和eMMC区别

DDR3内存条和eMMC存储器区别&#xff1a; 1. 存储性质不同&#xff1b;2. 存储容量不同&#xff1b;3. 运行速度不同&#xff1b;4. 用途不同。 具体区别如下&#xff1a; 1、存储性质不同&#xff1a;eMMC是非易失性存储器&#xff0c;不论在通电或断电状态下&#xff0c;数据…