基础知识——多线程

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------

11.多线程

11.1什么是进程？

进程简单说，就是正在运行的程序，比如，在windows操作系统中，从任务管理器中可以看到，只要打开一个应用程序，就开启一个进程。

11.1什么是线程？

线程是比进程更小的执行单位，是用来执行进程中的内容的，线程也称为执行路径或控制单元。

一个进程中，至少有一个线程，这些进程通过抢夺CPU的执行时间片，获取被CPU处理的权利。完成程序的运行。比如，在windows操作系统中，可以同时打开多个应用程序，这些应用程序，似乎是在同时运行。事实上是因为CPU运算速度很快，实际上是在不同的进程间进行切换。想想，如果一个进程中，有多个线程，那么获取CPU执行权时，多线程机制就能执行多个程序块，进而提高效率，这就是多线程。确切的说，在同一时间片内，只有一个进程中的一条线程在执行。

       开启多线程的目的是为了同时执行多部分代码。

11.2多线程的好处和弊端

好处：多个程序同时执行。

弊端：程序太多，效率低，易死机。

11.3 JVM中的线程

JVM开启至少有两条线程：一条线程执行主函数，一条线程执行垃圾回收。

11.4创建多线程的两种方式

第一种方式：继承Thread类

1,创建一个类继承Thread类，继承Thread类的类也称为线程类．

2,覆写run()方法.(run()方法中，封装的就是线程要执行的任务)

3,创建Thread子类的对象。

4,调用Thread类的start()方法，开启线程。

定义格式：

class类名extendsThread{

      定义属性；

      定义方法；

public void run（）{//复写Thread类中的run方法

      定义线程的任务；

}

示例代码：

class MyThread extends Thread{//创建一个类继承Thread类

   private Stringname;//定义属性

   MyThread(String name){//定义有参的构造函数

      this.name=name;

   }

   public void run(){//覆写Thread类的run()方法，注意，run()方法中封装的就是线程的任务。

      for (int i = 0; i < 10; i++) {      

         System.out.println(name+"...运行中....."+i);     

      }     

   }  

}

public class ThreadDemo {

 

   public static void main(String[] args) {

      MyThread mt1=new MyThread("线程A");//创建线程对象

      MyThread mt2=new MyThread("线程B");//创建线程对象

      mt1.start();//开启线程，实际上是调用Thread类的start（）方法。

      mt2.start();//开启线程   

   }

}

/*

 * 开启线程，线程会去执行run()方法中的内容.

 * 运行结果：(每次运行的结果不一定相同)

 * 线程A...运行中.....0

线程B...运行中.....0

线程A...运行中.....1

线程B...运行中.....1

线程A...运行中.....2

线程B...运行中.....2

线程B...运行中.....3

线程B...运行中.....4

线程B...运行中.....5

线程A...运行中.....3

线程A...运行中.....4

线程A...运行中.....5

线程A...运行中.....6

线程A...运行中.....7

线程A...运行中.....8

线程A...运行中.....9

线程B...运行中.....6

线程B...运行中.....7

线程B...运行中.....8

线程B...运行中.....9

*/

 

从上面可以看出，创建的两条线程：线程A和线程B，调用Thread类的start（）方法后，都分别执行了run（）方法中的代码。

那么，如果start（）开启线程，目的是执行run（）方法中的内容，为什么不直接运行run（）方法呢？

因为，start（）方法，目的是开启一条线程，start（）方法内部调用了线程对象的run（）方法，并由线程去执行内部内容。而，如果直接用线程对象调用run（）方法，实际上只是调用了一般方法run（），并没有开启线程。

 

Java中每个线程都有默认的线程名称，如：Thread-x，x是数字，默认从零开始。也可以在创建线程对象时，自定义线程名称，可以通过Thread类的静态方法currentThread（），获取当前运行的线程对象，再调用getName（）方法，获取线程的名称。通过setName（）可以修改线程的名称。

示例代码：

class MyThread extends Thread{//创建一个类继承Thread类

   private Stringname;//定义属性

   public void run(){//覆写Thread类的run()方法，注意，run()方法中封装的就是线程的任务。

      for (int i = 0; i < 10; i++) {      

         System.out.println(Thread.currentThread().getName()+"...运行中....."+i);//获取当前运行的线程名称    

      }     

   }  

}

public class ThreadDemo {

 

   public static void main(String[] args) {

      MyThread mt1=new MyThread();//创建线程对象

      MyThread mt2=new MyThread();//创建线程对象

//    mt1.setName("线程A");这里还能修改线程的名称．

//    mt2.setName("线程B");

      mt1.start();

      mt2.start();

   }

}

/*

 * 运行结果：

 * 

 * Thread-0...运行中.....0

   Thread-0...运行中.....1

   Thread-0...运行中.....2

   Thread-0...运行中.....3

   Thread-0...运行中.....4

   Thread-0...运行中.....5

   Thread-0...运行中.....6

   Thread-1...运行中.....0

   Thread-1...运行中.....1

   Thread-1...运行中.....2

   Thread-1...运行中.....3

   Thread-1...运行中.....4

   Thread-1...运行中.....5

   Thread-1...运行中.....6

   Thread-1...运行中.....7

   Thread-1...运行中.....8

   Thread-1...运行中.....9

   Thread-0...运行中.....7

   Thread-0...运行中.....8

   Thread-0...运行中.....9

 */

 

 

注意：一个线程对象的start（）方法，只能被调用一次，重复调用一个线程对象的start（）方法，

就会抛出：IllegalThreadStateException异常。

如：

class MyThread extends Thread{//创建一个类继承Thread类

   private Stringname;//定义属性

   public void run(){//覆写Thread类的run()方法，注意，run()方法中封装的就是线程的任务。

      for (int i = 0; i < 10; i++) {      

         System.out.println(Thread.currentThread().getName()+"...运行中....."+i);//获取当前运行的线程名称    

      }     

   }  

}

public class ThreadDemo {

   public static void main(String[] args) {

      MyThread mt1=newMyThread();//创建线程对象

      MyThread mt2=new MyThread();//创建线程对象

//    mt1.setName("线程A");这里还能修改线程的名称．

//    mt2.setName("线程B");

      mt1.start();

      mt1.start();//调用两次mt1线程对象的start()

      mt2.start();

   }

}

 

异常信息：

Exception in thread "main" java.lang.IllegalThreadStateException

    at java.lang.Thread.start(Thread.java:595)

    at 多线程.ThreadDemo.main(ThreadDemo.java:17)

 

第二种方式：实现Runnable接口

1， 创建一个类实现Runnable接口。

2， 覆盖Runnable接口的run（）方法，定义线程的任务内容。

3， 创建Runnable的子类对象。

4， 创建Thread类对象，并把实现Runnable的子类对象作为参数传递给Thread对象的构造函数。

5， 调用Thread对象的start（）方法，开启线程。

定义格式：

class类名implements Runnable{

      定义属性；

      定义方法；

public void run（）{//复写Thread类中的run方法

      定义线程的任务；

}

   

//示例代码：

class MyThread implements Runnable{//创建一个类实现Runnable接口

   private String name;//定义属性

   public void run(){//覆写Runnable接口的run()方法，将线程任务封装。

      for (int i = 0; i < 10; i++) {      

         System.out.println(Thread.currentThread().getName()+"...运行中....."+i);   

      }     

   }  

}

public class ThreadDemo {

   public static void main(String[] args) {

      MyThread mt1=new MyThread();//创建线程对象

      MyThread mt2=new MyThread();//创建线程对象

/*注意：实现Runnable接口的类的对象，并不是线程对象，只是将线程要执行的任务进行了封装，不能直接调用start()方法．

 * 只能将此对象，作为参数传递给Thread类的构造函数，由Thread类去开启线程．

 */

      //创建两个线程对象，将任务对象作为参数传递给Thread对象的构造函数．

      Thread t1=new Thread(mt1);

      Thread t2=new Thread(mt2);

      //由线程对象，开启两条线程．

      t1.start();

      t2.start();

   }

}

/*

 * 运行结果：

Thread-0...运行中.....0

Thread-0...运行中.....1

Thread-0...运行中.....2

Thread-0...运行中.....3

Thread-0...运行中.....4

Thread-1...运行中.....0

Thread-1...运行中.....1

Thread-1...运行中.....2

Thread-1...运行中.....3

Thread-1...运行中.....4

Thread-1...运行中.....5

Thread-1...运行中.....6

Thread-1...运行中.....7

Thread-1...运行中.....8

Thread-1...运行中.....9

Thread-0...运行中.....5

Thread-0...运行中.....6

Thread-0...运行中.....7

Thread-0...运行中.....8

Thread-0...运行中.....9

 */


 

继承Thread类和实现Runnable接口有什么区别？

1,继承Thread类的类，就是一个线程类，可以直接调用start()方法，run()封装的线程任务，只是线程类中的一员．

2,实现Runnable接口的类，实际上将线程的任务进行了分离，进行了任务的封装，再由Thread类去执行线程中的任务．实现Runnable接口，可以避免单继承的局限性，而且，更方便于资源共享．

//如：卖票示例

A：继承Thread类：

class MyTicket extends Thread{//创建一个类继承Thread

   private int num;//定义属性

   private String name;//定义属性

   MyTicket(int num,String name){//定义一个有参构造函数

      super(name);

      this.num=num;

   }

   public void run(){//覆写run()方法

      for (int i = 1; i<= 20; i++) {

         if(num>0){

         System.out.println(Thread.currentThread().getName()+"正在卖第"+num--+"票");
         }
      }
   }
}

public class ThreadDemo {

   public static void main(String[] args) {

      MyTicket mt1=new MyTicket(10,"窗口1");//创建线程对象

      MyTicket mt2=new MyTicket(10,"窗口2");//创建另一个线程对象．

      mt1.start();//开启线程

      mt2.start();//开启另一条线程

   }

}

 

/*

打印结果：

窗口2正在卖第10票

窗口2正在卖第9票

窗口2正在卖第8票

窗口2正在卖第7票

窗口2正在卖第6票

窗口2正在卖第5票

窗口2正在卖第4票

窗口2正在卖第3票

窗口2正在卖第2票

窗口2正在卖第1票

窗口1正在卖第10票

窗口1正在卖第9票

窗口1正在卖第8票

窗口1正在卖第7票

窗口1正在卖第6票

窗口1正在卖第5票

窗口1正在卖第4票

窗口1正在卖第3票

窗口1正在卖第2票

窗口1正在卖第1票

*/

//由些可见，两个线程各卖出了10张票．

 

B：实现Runnable接口

class MyTicket implements Runnable{//创建一个类implements Runnable

   private int num;//定义属性

   private String name;//定义属性

   MyTicket(int num){//定义一个有参构造函数

      this.num=num;

   }

   public void run(){//覆写run()方法

      for (int i = 1; i<= 20; i++) {

         if(num>0){

         System.out.println(Thread.currentThread().getName()+"正在卖第"+num--+"票");

         }

      }

   }

}

public class ThreadDemo {

   public staticvoid main(String[] args) {

      MyTicket mt=new MyTicket(10);//创建Runnable子类对象，相当于创建线程任务对象．

      Thread t1=new Thread(mt,"窗口1");//创建线程对象，把任务传递给线程对象的构造函数．

      Thread t2=new Thread(mt,"窗口2");//创建另一个线程对象

      t1.start();//开启线程

      t2.start();//开启另一条线程

   }

}

 

/*

打印结果：

窗口2正在卖第10票

窗口2正在卖第9票

窗口2正在卖第8票

窗口2正在卖第7票

窗口2正在卖第6票

窗口1正在卖第5票

窗口1正在卖第4票

窗口1正在卖第3票

窗口1正在卖第2票

窗口1正在卖第1票

*/

总结：由此可见，两个线程共同卖出了总的票数，１０张票，所以，实现Runnable接口的多线程，可以轻松实现资源共享．当然,继承Thread类，也可以实现资源共享，需要将共同操作的资源分离出来，操作起来相对复杂一些．

 

11.5线程的状态

线程的5种状态：创建、运行、冻结、阻塞、消亡。

如图：

 

 11.6线程安全问题

其实，多线程的运行过程是存在一定的安全隐患的．一般在理想状态下，安全问题的产生可能性很小，这里通过人为控制线程的状态，可以发现线程存在的安全隐患．

class MyTicket implements Runnable{//创建一个类implements Runnable

   private int num;//定义属性

   private String name;//定义属性

   MyTicket(int num){//定义一个有参构造函数

      this.num=num;

   }

   public void run(){//覆写run()方法

      for (int i = 1; i<= 20; i++) {

         if(num>0){

            try {

                Thread.sleep(10);//当线程执行到这一步时，会sleep(10毫秒)。

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

         System.out.println(Thread.currentThread().getName()+"正在卖第"+num--+"票");

         }

      }

            

   }

}

public class ThreadDemo {

   public static void main(String[] args) {

      MyTicket mt=new MyTicket(10);//创建Runnable子类对象，相当于创建线程任务对象．

      Thread t1=new Thread(mt,"窗口1");//创建线程对象，把任务传递给线程对象的构造函数．

      Thread t2=new Thread(mt,"窗口2");//创建另一个线程对象

      t1.start();//开启线程

      t2.start();//开启另一条线程

   }

}

/*

窗口2正在卖第10票

窗口2正在卖第9票

窗口2正在卖第8票

窗口2正在卖第7票

窗口2正在卖第6票

窗口1正在卖第5票

窗口1正在卖第4票

窗口1正在卖第3票

窗口1正在卖第2票

窗口1正在卖第1票

窗口2正在卖第0票

 

*/

 

从打印结果，可以看出，总票数为10张，却卖出了第0张票，这里就存在着线程的安全隐患．

因为，以上代码中创建了两条线程，当A线程在执行到Thread.sleep(10)方法时，就会被冻结，释放执行资格和执行权，此时CPU可能会切换到另一个线程B，当B线程执行到Thread.sleep(10)时，也会被冻结，此时，由于A线程可能睡眠时间到了，重新获取到CPU的执行权，开始执行：

System.out.println(Thread.currentThread().getName()+"正在卖第"+num--+"票");假设此时num=2，对num--后，num=1，A再次循环执行，当A线程执行到Thread.sleep(10)又会释放执行资格和执行权，此时可能会切换到B线程，B线程对num—后，就变成了0，输出。 

线程安全问题产生的原因：

1，有多条线程在操作共享的资源。

2，多条线程操作的共享数据的代码有多条。 

如何解决线程安全问题?

解决思路：当多条线程在操作共享数据时，在同一时间只允许一条线程操作共享数据，只有共享的数据操作完后，才允许下一条线程操作。

解决方式：Java中的同步代码块。

 

格式：

synchronized(Object obj){

      需要被同步的代码；

}

obj:相当于一个锁，每个线程都会持有锁，只有持有锁的线程，才能执行同步代码块，其它线程必须等到持有的锁释放后，才能有一个线程再次持有锁，执行被同步的代码。也就是说，在同一时间内，只能有一个线程能够持有锁，并执行需要被同步的代码。同步解决了线程的安全问题，但是也存在一定的弊端。

 

同步的好处和弊端：

好处：解决了线程安全问题。

弊端：降低了效率，因为同步代码块外面的线程，每次都要判断锁。

 

总结：多个线程如果要完成同步，可以将线程要操作的共享数据加到同步代码块中，但必须要用同一个锁，这是同步的前提。注意区分，哪些是要被同步的代码，哪些不需要。

注意：同步代码块中的锁，是用Object类型接收的，也就是说可以是任意的对象，但是，必须要保证对象的唯一。否则，就没法实现多线程同步。

//示例代码：（加入同步代码块，解决线程安全问题）

class MyTicket implements Runnable{//创建一个类implements Runnable

   Object obj=new Object();//创建Object对象，作为同步代码块的锁．

   private int num;//定义属性

   private String name;//定义属性

   MyTicket(int num){//定义一个有参构造函数

      this.num=num;

   }

   public void run(){//覆写run()方法

      for (int i = 1; i<= 20; i++) {      

         synchronized(obj){//加入同步代码块

            while(num>0){

            try {

                Thread.sleep(10);

            } catch (InterruptedException e) {

                //TODO Auto-generated catch block

                e.printStackTrace();

            }

         System.out.println(Thread.currentThread().getName()+"正在卖第"+num--+"票");

            }

         }

      }           

   }

}

public class ThreadDemo {

   public static void main(String[] args) {

      MyTicket mt=new MyTicket(10);//创建Runnable子类对象，相当于创建线程任务对象．

      Thread t1=new Thread(mt,"窗口1");//创建线程对象，把任务传递给线程对象的构造函数．

      Thread t2=new Thread(mt,"窗口2");//创建另一个线程对象

      Thread t3=new Thread(mt,"窗口2");//创建另一个线程对象

      Thread t4=new Thread(mt,"窗口2");//创建另一个线程对象

      t1.start();//开启线程t1

      t2.start();//开启线程t2

      t3.start();//开启线程t3

      t4.start();//开启线程t4

   }

}

/*

窗口1正在卖第10票

窗口1正在卖第9票

窗口1正在卖第8票

窗口1正在卖第7票

窗口1正在卖第6票

窗口1正在卖第5票

窗口1正在卖第4票

窗口1正在卖第3票

窗口1正在卖第2票

窗口1正在卖第1票

*/

 

由此可见，解决了线程的安全问题．

 11.7同步函数和静态同步函数

线程安全问题，用同步代码可以解决，同步函数和静态同步函数同样可以解决线程的安全问题．

同步函数的格式：

权限修饰符　synchronized返回值类型　方法名(){

      需要被同步的代码；

}

静态同步函数格式：

权限修饰符　static　synchronized返回值类型　方法名(){

      需要被同步的代码；

}

同步函数和同步代码块有什么区别？

首先，同步代码块的锁是任意的对象，只要保证唯一性，就能实现同步．但同步函数和静态同步函数的锁是固定的，同步函数的锁，是本类对象的引用:this,而静态同步函锁的锁，是本类对象所属的字节码文件对象，可以通过对象的getClass()或类名．class属性获取．建议使用同步代码块．

//如：(以上代码可以用同步函数替代同步代码块）

class MyTicket implements Runnable{//创建一个类implements Runnable

   Object obj=new Object();//创建Object对象，作为同步代码块的锁．

   private int num;//定义属性

   private String name;//定义属性

   MyTicket(int num){//定义一个有参构造函数

      this.num=num;

   }

   public void run(){//覆写run()方法

         while(true){

            show();//调用同步函数．

         }

   }

   public synchronized void show(){//定义同步函数，将线程要操作的任务封装．

      if(num>0){

         try {

            Thread.sleep(10);

            } catch (InterruptedException e) {

            e.printStackTrace();

            }

      System.out.println(Thread.currentThread().getName()+"正在卖第"+num--+"票");

         }

      }

   }

 

public class ThreadDemo {

   public static void main(String[] args) {

      MyTicket mt=new MyTicket(10);//创建Runnable子类对象，相当于创建线程任务对象．

      Thread t1=new Thread(mt,"窗口1");//创建线程对象，把任务传递给线程对象的构造函数．

      Thread t2=new Thread(mt,"窗口2");//创建另一个线程对象

      Thread t3=new Thread(mt,"窗口2");//创建另一个线程对象

      Thread t4=new Thread(mt,"窗口2");//创建另一个线程对象

      t1.start();//开启线程t1

      t2.start();//开启线程t2

      t3.start();//开启线程t3

      t4.start();//开启线程t4

   }

}

/*

窗口1正在卖第10票

窗口1正在卖第9票

窗口1正在卖第8票

窗口1正在卖第7票

窗口1正在卖第6票

窗口1正在卖第5票

窗口1正在卖第4票

窗口1正在卖第3票

窗口1正在卖第2票

窗口1正在卖第1票
*/

 

实现了同步．

 

11.8多线程的死锁

多线程的死锁，多发生在同步代码块的嵌套中，线程互相持有对方的锁，不释放，且线程又相互等待对方的锁释放。在实际开发中，要避免死锁的出现。

//死锁的代码示例：

class MyLock{//定义一个类分别创建两个对象，作为同步代码块的锁

   public static final MyLocklock1=new MyLock();

   public static final MyLocklock2=new MyLock();

   

}

class ThreadDemo implements Runnable{

   private boolean flag;//定义标记

   ThreadDemo(boolean flag){//定义构造函数，并把标记作为参数

      this.flag=flag;   

   }

   @Override

   public void run() {//复写run()方法

      while(true){//定义无限循环

         if(flag){//标记为true时，线程A执行任务。

            synchronized(MyLock.lock1){//同步代码块中嵌套同步代码块，持有lock1锁

                System.out.println(Thread.currentThread().getName()+"．．lock1．．．线程正在运行．．．．");

                synchronized(MyLock.lock2){//持有lock2

                   System.out.println(Thread.currentThread().getName()+"．．．lock2．．线程正在运行．．．．");

                }

            }

         }else{//标记为false时，线程B执行任务。

            synchronized(MyLock.lock2){//持有lock1

                System.out.println(Thread.currentThread().getName()+"．．lock2．．．线程正在运行．．．．");

                synchronized(MyLock.lock1){//持有lock2

                   System.out.println(Thread.currentThread().getName()+"．．．lock1．．线程正在运行．．．．");
               }

            }        

         }

      }

   }

}

public class DeadLock{

   public static void main(String[]args){

         //创建线程任务

         ThreadDemo td1=new ThreadDemo(true);

         ThreadDemo td2=new ThreadDemo(false);

         //创建线程对象

         Thread t1=new Thread(td1,"线程A");

         Thread t2=new Thread(td2,"线程B");

         //开启线程

         t1.start();

         t2.start();

   }

}

/*

 *线程A．．lock1．．．线程正在运行．．．．

 *线程B．．lock2．．．线程正在运行．．．．

 *

 *发生死锁的现象

*/

 

以上代码中，当一个线程在执行时，只要另一个线程具有了CPU执行权时，就会发生相互在持有对方的锁，所以就发生了死锁的现象．

 

11.9线程间的通信

线程间的通信：多个线程在操作同一个资源，执行不同任务．

线程间的通信，涉及到对线程的状态操作，就是线程的等待、唤醒机制。

操作线程状态的方法：

1， wait（）：此方法，可以让线程处于冻结状态，被wait（）的线程存储在线程池中。

2， notify（）：此方法，可以唤醒线程池中处于冻结状态的任意一个线程。

3， notifyAll（）：次方法，可以唤醒线程池中所有的线程。

注意:这几个方法，都封装在Object类，且这些方法必须要使用在同步中，因为这些方法是操作线程状态的方法，必须要明确操作的是哪个锁上的线程．因为，锁可以是任意的对象，所以这几个方法，被封装在了Object类中．

示例代码：(在线程中加入等待、唤醒机制)

需求：模拟电脑工厂生产电脑，生产一台，就停止生产，等到销售完成后再继续生产，并保证多线程的同步。

如图：

class Computer{//创建Computer类，这是线程要操作的同一资源

   private int count=0;

   private boolean flag=false;

   private String name;

   Computer(String name){

      this.name="台"+name;

   }

   public synchronized void proComputer(){//对外提供生产的方法

      while(flag)//判断标记，标记为true时，不生产。

         try {

            wait();//通过wait（）方法，让线程冻结。

         } catch (InterruptedException e) {

            e.printStackTrace();

         }

      count++;

      System.out.println(Thread.currentThread().getName()+"．．．．正在生产第"+count+name);

      flag=true;//生产完后，将标记改为true，代表生产结束，操作生产的线程，就会被wait（）

      notifyAll();//这里要唤醒线程池中，所有冻结的线程，否则，随着标记和判断，所有线程都会被wait();

      

   }

   public synchronized void sellComputer(){//对外提供销售的方法

      while(!flag)//只有当flag为true时，代表生产完成，开始销售。

         try {

            wait();

         } catch (InterruptedException e) {

            e.printStackTrace();

         }

      System.out.println(Thread.currentThread().getName()+"．．．．正在销售第"+count+name);

      flag=false;//销售完成后，标记改为false，销售的线程判断while（！flag）时，销售线程停止。

      notifyAll();//这里要唤醒线程池中，所有冻结的线程，否则，随着标记和判断，所有线程都会被wait();

   } 

}

class Produce implements Runnable{//创建负责生产的类

   private Computer c;

   Produce(Computer c){//定义构造函数接收要操作的资源。

      this.c=c;

   }

   public void run(){//线程的任务就是，Computer类中封装在proComputer（）方法的内容。

      while(true){

         

         c.proComputer();

      }

   }

   

}

class Sell implements Runnable{

   private Computer c;

   Sell(Computer c){//定义构造函数接收要操作的资源。

      this.c=c;

   }

   public void run(){//线程的任务就是，Computer类中封装在sellComputer（）方法的内容。

      while(true){

      c.sellComputer();

      }

   }

}

public class ProAndSel{

   public static void main(String[]args)throws InterruptedException{

      //1,创建线程操作的资源

      Computer c=new Computer("笔记本电脑");

      //2,创建线程的任务

      Produce pro=new Produce(c);

      Sell sell=new Sell(c);

      //3,创建线路程对象

      Thread t1=new Thread(pro,"工厂A");

      Thread t2=new Thread(pro,"工厂B");

      Thread t3=new Thread(sell,"销售A");

      Thread t4=new Thread(sell,"销售B");

      //4,开启线程

      t1.start();

      t2.start();

      t3.start();

      t4.start();

   

   }

}

 

在上面代码中各有两条线程负责生产和销售，通过判断标记来让线程等待和执行，在这里标记和判断要用while，不能用if，因为if只判断一次，而while多次判断，可以避免线程安全问题，且，四条线程都同属于一个线程池，如果用while判断标记，就必须用notifyAll进行唤醒，否则，所有线程都有可能被wait（），因此可见，四条线程，不论谁被wait，都会被唤醒。考虑到，生产和销售各有两条线程，在同一时间内，只有一条线程在执行，相互间交替执行。如何做到，生产完成后，只唤醒销售的线程；而销售完成后，只唤醒生产的线程.也就是只唤醒对方的线程，提高效率呢？

 

JDK1.5对此类问题进行了解决．

java.util.concurrent.locks.Lock接口

Lock，对锁的操作进行了封装，将原来同步代码块中获取锁和释放锁的隐式操作，变成了显示操作。在之前多条线程只要使用同一个锁，就都同属于一个线程池，这个锁只有一组操作线程状态的方法wait（）、notify（）、notifyAll（），能够操作线程池的所有线程。而Lock，可以让一个锁，产生多组线程操作的方法，可以分别操作同一个锁上的线程，让他们单独具备不同的线程状态。

 

 

 Lock如使用：

Lock lock=new ReentrantLock();//获取锁对象．

Condition con1=lock.newCondition();//相当于获取一组操作锁上线程的方法。

Conditon con2=lock.newCondition();//获取另一组操作锁上线程的方法。

lock.lock();//调用lock()方法，获取锁。

try{

      需要被同步的代码；

}

finally{{

       lock.unlock();//释放锁

}

注意：释放锁的动作一定要放在finally代码块中执行。

示例代码：（使用JDK1.5如Lock锁，实现同步和相互唤醒）

 

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

 

class Computer{//创建Computer类，这是线程要操作的同一资源

   private int count=0;

   private boolean flag=false;

   private String name;

   Lock lock=new ReentrantLock();//获取锁对象

   Condition con1=lock.newCondition();//创建两组操作线程的方法．一组操作生产.

   Condition con2=lock.newCondition();//一组操作销售.

   Computer(String name){

      this.name="台"+name;

   }

   public void proComputer(){//对外提供生产的方法

      lock.lock();//获取锁

      try{

      while(flag)//判断标记，标记为true时，不生产。

         try {

            con1.await();//让生产线程冻结。

         } catch (InterruptedException e) {

            e.printStackTrace();

         }

      count++;

      System.out.println(Thread.currentThread().getName()+"．．．．正在生产第"+count+name);

      flag=true;//生产完后，将标记改为true，代表生产结束，操作生产的线程，就会被await（）

      con2.signal();//唤醒对方的线程。

      }

      finally{

         lock.unlock();//释放锁。

      }

      

   }

   public void sellComputer(){//对外提供销售的方法

      lock.lock();

      try{

      while(!flag)//只有当flag为true时，代表生产完成，开始销售。

         try {

            con2.await();//让销售线程冻结

         } catch (InterruptedException e) {

            e.printStackTrace();

         }

      System.out.println(Thread.currentThread().getName()+"．．．．正在销售第"+count+name);

      flag=false;//销售完成后，标记改为false，销售的线程判断while（！flag）时，销售线程冻结。

      con1.signal();//唤醒生产的线程。

      }

      finally{

         lock.unlock();//释放锁

      }

   } 

}

class Produce implements Runnable{//创建负责生产的类

   private Computer c;

   Produce(Computer c){//定义构造函数接收要操作的资源。

      this.c=c;

   }

   public void run(){//线程的任务就是，Computer类中封装在proComputer（）方法的内容。

      while(true){
        c.proComputer();
      }
   }
}

class Sell implements Runnable{

   private Computer c;

   Sell(Computer c){//定义构造函数接收要操作的资源。

      this.c=c;

   }

   public void run(){//线程的任务就是，Computer类中封装在sellComputer（）方法的内容。

      while(true){

      c.sellComputer();

      }

   }

}

public class ProAndSel{

   public static void main(String[]args)throws InterruptedException{

      //1,创建线程操作的资源

      Computer c=new Computer("笔记本电脑");

      //2,创建线程的任务

      Produce pro=new Produce(c);

      Sell sell=new Sell(c);

      //3,创建线路程对象

      Thread t1=new Thread(pro,"工厂A");

      Thread t2=new Thread(pro,"工厂B");

      Thread t3=new Thread(sell,"销售A");

      Thread t4=new Thread(sell,"销售B");

      //4,开启线程

      t1.start();

      t2.start();

      t3.start();

      t4.start();

   }

}

总结：JDK1.5出现的Lock，实际上是替代了同步代码块synchronized，将锁变成了显示操作。Condition中的await（）、signal（）、signalAll（）替代了，Object类中的wait（）、notify（）和notifyAll（）；且一个锁可以创建多组操作线程的方法，实现对线程状态的分别控制。 

wait（）和sleep（）的区别?

1，  wait()：可以指定时间，也可以不指定。

sleep()：必须要指定时间。

2，  wait():线程释放执行权，释放锁。

sleep():线程释放执行权，但不释放锁。

 

12.0线程的其他方法

1. public void interrupt()

此方法可清除线程冻结的状态．是强制唤醒一个被冻结的线程，会发生异常：InterruptedException

此方法还可以用来结束线程．

class ThreadDemo implements Runnable{

   private int count=1;

   private boolean flag=true; 

   @Override

   public void run() {

      while(flag){

      synchronized(this){                          

                //System.out.println(count++);

                count++;

                if (count>10) {

                 try {

                wait();//当count的值大于１０时，线程被冻结，由主函数的线程中断方法，强制唤醒线程．因为会有异常，InterruptedException发生．

                      System.out.println("线程等待解除！");

                   } catch (InterruptedException e) {//这里接收主函数中调用interrupt()方法，中断线程时，所产生的异常．

                      flag=false;//在这里把标记改为false停止线程任务，完成对线程的结束控制．        

                      System.out.println("线程标记为false，线程结束");

                }                 

            }

         }

      }

   }

}  

 

public class Demo {

 

   public static void main(String[] args) {

      ThreadDemo td=new ThreadDemo();

      Thread t1=new Thread(td);

      Thread t2=new Thread(td);

      t1.start();//开启线程

      t2.start();//开启线程

      int count=0;

      for(;;){

         count++;

         if(count>100){//通过循环递增count的值，如果大于５０

            System.out.println(count);

            t1.interrupt();//就对线程t1,t2执行中断．

            t2.interrupt();    

            break;

         }

      }     

   }

}

/*

打印结果：

101

线程标记为false，线程结束

 */

 
 

2. public final boolean isDaemon()

此方法，可以将线程设置后台线程，后台线程的特点是：当所有前台线程结后，后台线程自动结束．

如：

class ThreadDemo1 implements Runnable{

   private int count=0;

   @Override

   public void run() {//t1 t2线程的任务是无限循环的

      while(true){

      synchronized(this){                          

            System.out.println(Thread.currentThread().getName()+"...."+count++);

         }

      }

   }

}  

class ThreadDemo2 implements Runnable{

   private int count=0;

   @Override

   public void run() {//t3 t4的任务是，当　count>100时，停止循环．

      while(true){

         synchronized(this){

            System.out.println(Thread.currentThread().getName()+"...."+count++);

            if(count>100){

                break;

            }

         }

      }

   }  

}

public class Demo {

 

   public static void main(String[] args) {

      ThreadDemo1 td1=new ThreadDemo1();

      ThreadDemo2 td2=new ThreadDemo2();

      Thread t1=new Thread(td1);

      Thread t2=new Thread(td1);

      Thread t3=new Thread(td2);

      Thread t4=new Thread(td2);

      //设置t1 t2为后台线程．

      t1.setDaemon(true);

      t2.setDaemon(true);

      

      t1.start();//开启线程

      t2.start();//开启线程

      t3.start();//开启线程

      t4.start();//开启线程

      

   }

}

 

以上代码中，t1、 t2线程的任务是无限循环，而t3、t4的任务加了循环的次数判断，当大于100时，t3、t4的线程任务结束。因为t1、t2是后台线程，随着t3、 t4的结束，t1、 t2也相继结束任务。

 

3. public final void join()

此方法的作用是，哪个线程调用此方法，当前正在被执行的线程就把执行权交给调用join（）方法的线程，自己处于冻结状态，直到调用join（）方法的线程结束后，再抢夺CPU执行权。

4. public final void setPriority(int newPriority)

此方法，用于设置线程的优先级，线程的默认优先级为NORM_PRIORITY.

线程的优先级分为：

MAX_PRIORITY(最高，整数值:10)、NORM_PRIORITY（中等，整数值：5）、MIN_PRIORITY（最低，整数值：1）.线程优先级越高被CPU先执行的几率越大。

5. public static void yield()

暂停当前线程，执行其他线程。

6. public String toString()

返回该线程的字符串表示形式，包括线程名称、优先级和线程组。

如：public class Demo {

   public static void main(String[] args){

      Thread t1=new Thread();

      System.out.println(t1.toString());

   }

}

/*

 * 打印结果：Thread[Thread-0,5,main]

 */

 

总结：关于多线程，在应用中要注意线程的安全问题，可以利用同步代码块、同步函数、静态同步函数或JDK1.5的Lock，来实现多线程步．操作线程状态的方法，必须要用在同步中。同步中应该避免没有条件控制的无限循环，这样会导致一个线程进入后，无法结束。要避免多线程中，相互持有对方的锁，以免发生死锁。

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------