[关闭]
@liayun 2016-05-28T03:15:37.000000Z 字数 17940 阅读 1401

多线程

java基础

进程

进程：是一个正在执行中的程序。
每一个进程执行都有一个执行顺序。该顺序就是一个执行路径或者叫一个控制单元。

线程

Java VM启动时会有一个进程java.exe，该进程中至少有一个线程负责java程序的执行。而且这个线程运行的代码存在main方法中，该线程称之为主线程。
扩展知识：其实更细节说明JVM，JVM不止启动一个线程，还有负责垃圾回收机制的线程。

创建线程方式一

如何在自定义的代码中，自定义定义一个线程？
答：通过对API的查找，java已经提供了对线程这类事物的描述，即Thread类。
创建线程的第一种方式：继承Thread类。
步骤：

  1. 继承Thread类
  2. 重写Thread类中的run()。目的：将自定义的代码存储在run()，让线程运行
  3. 调用线程的start()。该方法有2个作用：启动线程，调用run()

例，

  1. class Demo extends Thread {
  2.     public void run() {
  3.         for (int x = 0; x < 60; x++) {
  4.             System.out.println("demo run---"+x);
  5.         }
  6.     }
  7. }
  9. class ThreadDemo {
  10.     public static void main(String[] args) {
  11.         Demo d = new Demo(); // 创建好一个线程
  12.         // d.start(); // 开启线程，并执行该线程的run()
  13.         d.run(); // 仅仅是对象的调用方法，而线程创建了，并没有被运行
  15.         for (int x = 0; x < 60; x++) {
  16.             System.out.println("Hello World!---"+x);
  17.         }
  18.     }
  19. }

发现运行结果每一次都不同。
因为多个线程都在获取CPU的执行权，CPU执行到谁，谁就运行。明确一点，在某一个时刻，只能有一个程序在运行（多核除外）。CPU在做着快速的切换，以达到看上去是同时运行的效果。我们可以形象地把多线程的运行形容为互相抢夺CPU的执行权，这就是多线程的一个特点：随机性。谁抢到谁执行，至于执行多长，CPU说了算。
为什么要覆盖run()呢？
答：Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run()。也就是说Thread类中的run()用于存储线程要运行的代码。
练习：创建两个线程，和主线程交替执行。
解：

  1. class Test extends Thread {
  2.     Test(String name) {
  3.         super(name);
  4.     }
  5.     public void run() {
  6.         for (int x = 0; x < 60; x++) {
  7.             System.out.println((Thread.currentThread()==this)+"..."+this.getName()+" run..."+x);
  8.         }
  9.     }
  10. }
  11. class ThreadTest {
  12.     public static void main(String[] args) {
  13.         Test t1 = new Test("one---");
  14.         Test t2 = new Test("two+++");
  15.         t1.start();
  16.         t2.start();
  17.         for (int x = 0; x < 60; x++) {
  18.             System.out.println("main..."+x);
  19.         }
  20.     }
  21. }

通过上例，可发现原来线程都有自己默认的名称：Thread-编号，该编号从0开始。

线程的状态

线程的状态转换图

创建线程方式二

以此例引申出创建线程的第二种方式：
例，需求：简单的卖票程序。多个窗口同时买票。

  1. class Ticket implements Runnable {
  2.     private int tick = 100;
  3.     public void run() {
  4.         while(true) {
  5.             if(tick > 0) {
  6.                 try { Thread.sleep(10); } catch(Exception e) {}
  7.                 System.out.println(Thread.currentThread().getName()+"...sale:"+tick--);
  8.             }
  9.         }
  10.     }
  11. }
  12. class TicketDemo {
  13.     public static void main(String[] args) {
  14.         Ticket t = new Ticket();
  16.         Thread t1 = new Thread(t); // 创建一个线程
  17.         Thread t2 = new Thread(t); // 创建一个线程
  18.         Thread t3 = new Thread(t); // 创建一个线程
  19.         Thread t4 = new Thread(t); // 创建一个线程
  20.         t1.start();
  21.         t2.start();
  22.         t3.start();
  23.         t4.start();
  24.     }
  25. }

创建线程的第二种方式：实现Runnable接口。
步骤：

  1. 定义类实现Runnable接口
  2. 覆盖Runnable接口中的run()。目的：将线程要运行的代码存放在该run()中
  3. 通过Thread类建立线程对象
  4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
    为什么要将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数？
    答：因为自定义的run()所属的对象是Runnable接口的子类对象，所以要让线程去运行指定对象的run()，就必须明确该run()所属的对象
  5. 调用Thread类的start()开启线程并调用Runnable接口子类的run方法。

实现方式和继承方式有什么区别呢？
1. 实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现方式
2. 继承Thread：线程代码存放Thread子类的run()中
3. 实现Runnable：线程代码存放在接口的子类的run()中

线程安全问题

还是以简单的卖票程序为例，通过分析发现打印出0、-1、-2等错票，多线程的运行出现了安全问题。
问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致了共享数据的错误。
解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
java对于多线程的安全问题提供了专业的解决方式——就是同步代码块。
注意：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。

同步（synchronized）

格式：

synchronized(对象) {
    需要被同步的代码
}

对象如同锁，持有锁的线程可以在同步中执行。没有持有锁的线程即使获取CPU的执行权，也进不去，因为没有锁。
火车上的卫生间---经典同步例子。
同步的前提：

  1. 必须要有两个或者两个以上的线程
  2. 必须是多个线程使用同一个锁

必须保证同步中只有一个线程在运行。
同步的好处：解决了多线程的安全问题。
同步的弊端：多个线程需要判断锁，较为消耗资源。
所以同步之后的代码为：

  1. class Ticket implements Runnable {
  2.     private int tick = 100;
  3.     Object obj = new Object();
  4.     public void run() {
  5.         while(true) {
  6.             synchronized(obj) {
  7.                 if(tick > 0) {
  8.                     try { Thread.sleep(10); } catch(Exception e) {}
  9.                     System.out.println(Thread.currentThread().getName()+"...sale:"+tick--);
  10.                 }
  11.             }
  12.         }
  13.     }
  14. }
  15. class TicketDemo2 {
  16.     public static void main(String[] args) {
  17.         Ticket t = new Ticket();
  19.         Thread t1 = new Thread(t); // 创建一个线程
  20.         Thread t2 = new Thread(t); // 创建一个线程
  21.         Thread t3 = new Thread(t); // 创建一个线程
  22.         Thread t4 = new Thread(t); // 创建一个线程
  23.         t1.start();
  24.         t2.start();
  25.         t3.start();
  26.         t4.start();
  27.     }
  28. }

同步函数

以此例引申出同步函数，需求：银行有一个金库，有两个储户，分别存300元，每次存100元，存3次。目的：该程序是否有安全问题，如果有，如何解决？

  1. class Bank {
  2.     private int sum;
  3.     public void add(int n) {
  4.         sum = sum + n;
  5.         try {
  6.             Thread.sleep(10);
  7.         } catch (InterruptedException e) {
  9.         }
  10.         System.out.println("sum="+sum);
  11.     }
  12. }
  13. class Cus implements Runnable {
  14.     private Bank b = new Bank();
  15.     public void run() {
  16.         for(int x = 0; x < 3; x++) {
  17.             b.add(100);
  18.         }
  19.     }
  20. }
  21. class BankDemo {
  22.     public static void main(String[] args) {
  23.         Cus c = new Cus();
  24.         Thread t1 = new Thread(c);
  25.         Thread t2 = new Thread(c);
  26.         t1.start();
  27.         t2.start();
  28.     }
  29. }

解：
如何找到问题：

  1. 明确哪些代码是多线程运行代码
  2. 明确共享数据
  3. 明确多线程运行代码中哪些语句是操作共享数据的

所以，修改之后的代码为：

  1. class Bank {
  2.     private int sum;
  3.     // Object obj = new Object();
  4.     // 同步函数
  5.     public synchronized void add(int n) {
  6.         // synchronized(obj) {
  7.             sum = sum + n;
  8.             try {
  9.                 Thread.sleep(10);
  10.             } catch (InterruptedException e) {
  12.             }
  13.             System.out.println("sum="+sum);
  14.         // }
  15.     }
  16. }
  17. class Cus implements Runnable {
  18.     private Bank b = new Bank();
  19.     public void run() {
  20.         for(int x = 0; x < 3; x++) {
  21.             b.add(100);
  22.         }
  23.     }
  24. }
  25. class BankDemo {
  26.     public static void main(String[] args) {
  27.         Cus c = new Cus();
  28.         Thread t1 = new Thread(c);
  29.         Thread t2 = new Thread(c);
  30.         t1.start();
  31.         t2.start();
  32.     }
  33. }

思考：同步函数用的是哪一个锁呢？
结论：函数需要被对象调用，那么函数都有一个所属对象引用，就是this。所以同步函数使用的锁是this。
程序验证：通过该程序进行验证同步函数使用的锁是this。使用两个线程来卖票，一个线程在同步代码块中，一个线程在同步函数中，都在执行买票动作。

  1. class Ticket implements Runnable {
  2.     private int tick = 100;
  3.     Object obj = new Object();
  4.     boolean flag = true;
  5.     public void run() {
  6.         if(flag) {
  7.             while(true) {
  8.                 synchronized(this) {
  9.                     if(tick > 0) {
  10.                         try { Thread.sleep(10); } catch(Exception e) {}
  11.                         System.out.println(Thread.currentThread().getName()+"...code:"+tick--);
  12.                     }
  13.                 }
  14.             }
  15.         } else {
  16.             while(true) 
  17.                 show();
  18.         }
  19.     }
  20.     public synchronized void show() { // this
  21.         if(tick > 0) {
  22.             try { Thread.sleep(10); } catch(Exception e) {}
  23.             System.out.println(Thread.currentThread().getName()+"...show...:"+tick--);
  24.         }
  25.     }
  26. }
  27. class ThisLockDemo {
  28.     public static void main(String[] args) {
  29.         Ticket t = new Ticket();
  31.         Thread t1 = new Thread(t); // 创建一个线程
  32.         Thread t2 = new Thread(t); // 创建一个线程
  33.         t1.start();
  34.         // 主线程停10ms，此刻能运行的线程只有t1
  35.         try { Thread.sleep(10); } catch(Exception e) {}
  36.         t.flag = false;
  37.         // 主线程醒了之后，t1和t2线程同时运行
  38.         t2.start();
  39.     }
  40. }

又思考：如果同步函数被静态修饰后，使用的锁是什么呢？
通过验证，发现不再是this，因为静态方法中也不可以定义this。静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象：类名.class，该对象的类型是Class。
静态的同步方法，使用的锁是该方法所在类的字节码文件对象。即类名.class。
程序验证同上：

  1. class Ticket implements Runnable {
  2.     private static int tick = 100;
  3.     // Object obj = new Object();
  4.     boolean flag = true;
  5.     public void run() {
  6.         if(flag) {
  7.             while(true) {
  8.                 synchronized(Ticket.class) {
  9.                     if(tick > 0) {
  10.                         try { Thread.sleep(10); } catch(Exception e) {}
  11.                         System.out.println(Thread.currentThread().getName()+"...code:"+tick--);
  12.                     }
  13.                 }
  14.             }
  15.         } else {
  16.             while(true) 
  17.                 show();
  18.         }
  19.     }
  20.     public static synchronized void show() { 
  21.         if(tick > 0) {
  22.             try { Thread.sleep(10); } catch(Exception e) {}
  23.             System.out.println(Thread.currentThread().getName()+"...show...:"+tick--);
  24.         }
  25.     }
  26. }
  27. class StaticMethodDemo {
  28.     public static void main(String[] args) {
  29.         Ticket t = new Ticket();
  31.         Thread t1 = new Thread(t); // 创建一个线程
  32.         Thread t2 = new Thread(t); // 创建一个线程
  33.         t1.start();
  34.         // 主线程停10ms，此刻能运行的线程只有t1
  35.         try { Thread.sleep(10); } catch(Exception e) {}
  36.         t.flag = false;
  37.         // 主线程醒了之后，t1和t2线程同时运行
  38.         t2.start();
  39.     }
  40. }

单例设计模式

饿汉式：

  1. class Single {
  2.     private static final Single s = new Single();
  3.     private Single() {}
  4.     public static Single getInstance() {
  5.         return s;
  6.     }
  7. }

懒汉式：

  1. class Single {
  2.     private static Single s = null;
  3.     private Single() {}
  4.     public static Single getInstance() {
  5.         if(s == null) {
  6.             synchronized(Single.class) {
  7.                 if(s == null)
  8.                     s = new Single();
  9.             }
  10.         }
  11.         return s;
  12.     }
  13. }

面试时，可能会问懒汉式与饿汉式有什么不同？
答：懒汉式的特点用于实例的延迟加载。
又问懒汉式的延迟加载有没有问题？
答：有，如果多线程访问时会出现安全问题。
又问怎么解决？
答：可以加同步来解决，用同步代码块和同步函数都行，但是稍微有一些低效，用双重判断的形式能解决这个效率问题。
最后问加同步时，使用的锁是哪一个？
答：该类所属的字节码文件对象。

面试题：请给我写一个延时加载的单例模式示例？

死锁

同步中嵌套同步。
例，

  1. class Ticket implements Runnable {
  2.     private int tick = 1000;
  3.     Object obj = new Object();
  4.     boolean flag = true;
  5.     public void run() {
  6.         if(flag) {
  7.             while(true) {
  8.                 synchronized(obj) {
  9.                     show();
  10.                 }
  11.             }
  12.         } else {
  13.             while(true) 
  14.                 show();
  15.         }
  16.     }
  17.     public synchronized void show() { 
  18.         synchronized(obj) {
  19.             if(tick > 0) {
  20.                 try { Thread.sleep(10); } catch(Exception e) {}
  21.                 System.out.println(Thread.currentThread().getName()+"...code:"+tick--);
  22.             }
  23.         }
  24.     }
  25. }
  26. class DeadLockDemo {
  27.     public static void main(String[] args) {
  28.         Ticket t = new Ticket();
  30.         Thread t1 = new Thread(t); // 创建一个线程
  31.         Thread t2 = new Thread(t); // 创建一个线程
  32.         t1.start();
  33.         // 主线程停10ms，此刻能运行的线程只有t1
  34.         try { Thread.sleep(10); } catch(Exception e) {}
  35.         t.flag = false;
  36.         // 主线程醒了之后，t1和t2线程同时运行
  37.         t2.start();
  38.     }
  39. }

面试题：写一个死锁程序。

  1. class Test implements Runnable {
  2.     private boolean flag;
  3.     Test(boolean flag) {
  4.         this.flag = flag;
  5.     }
  6.     public void run() {
  7.         if(flag) {
  8.             while(true) {
  9.                 synchronized(MyLock.locka) {
  10.                     System.out.println("if locka");
  11.                     synchronized(MyLock.lockb) {
  12.                         System.out.println("if lockb");
  13.                     }
  14.                 }
  15.             }
  16.         } else {
  17.             while(true) {
  18.                 synchronized(MyLock.lockb) {
  19.                     System.out.println("else lockb");
  20.                     synchronized(MyLock.locka) {
  21.                         System.out.println("else locka");
  22.                     }
  23.                 }
  24.             }   
  25.         }
  26.     }
  27. }
  28. // 锁
  29. class MyLock {
  30.     static Object locka = new Object();
  31.     static Object lockb = new Object();
  32. }
  33. class DeadLockTest {
  34.     public static void main(String[] args) {
  35.         Thread t1 = new Thread(new Test(true));
  36.         Thread t2 = new Thread(new Test(false));
  37.         t1.start();
  38.         t2.start();
  39.     }
  40. }

线程间通信

其实就是多个线程在操作同一个资源，但是操作的动作不同。
notifyAll()：唤醒线程池中所有等待的线程。
notify()：唤醒线程池中第一个等待的线程。
wait()/notify()/notifyAll()：都使用在同步中，因为要对持有监视器（锁）的线程操作，所以要使用在同步中，因为只有同步才具有锁。
思考：wait(),notify(),notifyAll(),用来操作线程为什么定义在了Object类中？
答：

  1. 这些方法存在与同步中。
  2. 使用这些方法时必须要标识所属的同步的锁。
  3. 锁可以是任意对象，所以任意对象调用的方法一定定义在Object类中。

因为这些方法在操作同步中线程时，都必须标识它们所操作线程持有的锁，只有同一个锁上的被等待线程，才可以被同一个锁上的notify唤醒，不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object类中。

例，

  1. class Res {
  2.     String name;
  3.     String sex;
  4.     boolean flag = false;
  5. }
  6. class Input implements Runnable {
  7.     private Res r;
  8.     // Object obj = new Object();
  9.     Input(Res r) {
  10.         this.r = r;
  11.     }
  12.     public void run() {
  13.         int x = 0;
  14.         while(true) {
  15.             synchronized(r) {
  16.                 if(r.flag)
  17.                     try { r.wait(); } catch(Exception e) {} // wait持有r锁的线程
  18.                 if(x == 0) {
  19.                     r.name = "mike";
  20.                     r.sex = "man";
  21.                 } else {
  22.                     r.name = "丽丽";
  23.                     r.sex = "女女女女女";
  24.                 }
  25.                 x = (x+1)%2;
  26.                 r.flag = true;
  27.                 r.notify(); // notify持有r锁的等待线程
  28.             }
  29.         }
  30.     }
  31. }
  32. class Output implements Runnable {
  33.     private Res r;
  34.     // Object obj = new Object();
  35.     Output(Res r) {
  36.         this.r = r;
  37.     }
  38.     public void run() {
  39.         while(true) {
  40.             synchronized(r) {
  41.                 if(!r.flag)
  42.                     try { r.wait(); } catch(Exception e) {} 
  43.                 System.out.println(r.name+"...."+r.sex);
  44.                 r.flag = false;
  45.                 r.notify();
  46.             }
  47.         }
  48.     }
  49. }
  50. class InputOutputDemo {
  51.     public static void main(String[] args) {
  52.         Res r = new Res();
  53.         Input in = new Input(r);
  54.         Output out = new Output(r);
  55.         Thread t1 = new Thread(in);
  56.         Thread t2 = new Thread(out);
  57.         t1.start();
  58.         t2.start();
  59.     }
  60. }

思考：wait()，sleep()有什么区别？
答：

以上代码经过优化后：

  1. class Res {
  2.     private String name;
  3.     private String sex;
  4.     private boolean flag = false;
  6.     public synchronized void set(String name, String sex) {
  7.         if(flag)
  8.             try { this.wait(); } catch(Exception e) {}
  9.         this.name = name;
  10.         this.sex = sex;
  11.         flag = true;
  12.         this.notify();
  13.     }
  15.     public synchronized void out() {
  16.         if(!flag)
  17.             try { this.wait(); } catch(Exception e) {}
  18.         System.out.println(name+"........"+sex);
  19.         flag = false;
  20.         this.notify();
  21.     }
  22. }
  23. class Input implements Runnable {
  24.     private Res r;
  25.     // Object obj = new Object();
  26.     Input(Res r) {
  27.         this.r = r;
  28.     }
  29.     public void run() {
  30.         int x = 0;
  31.         while(true) {
  32.             if(x == 0) 
  33.                 r.set("mike", "man");
  34.             else
  35.                 r.set("丽丽", "女女女女女");
  36.             x = (x+1)%2;
  37.         }
  38.     }
  39. }
  40. class Output implements Runnable {
  41.     private Res r;
  42.     Output(Res r) {
  43.         this.r = r;
  44.     }
  45.     public void run() {
  46.         while(true) {
  47.             r.out();
  48.         }
  49.     }
  50. }
  51. class InputOutputDemo2 {
  52.     public static void main(String[] args) {
  53.         Res r = new Res();
  54.         new Thread(new Input(r)).start();
  55.         new Thread(new Output(r)).start();
  56.     }
  57. }

为了理解，我画了一个示意图，如下：
等待唤醒机制

线程操作案例——生产者和消费者（单个）

  1. public class ProducerConsumerDemo {
  3.     public static void main(String[] args) {
  4.         Resource r = new Resource();
  6.         Producer pro = new Producer(r);
  7.         Consumer con = new Consumer(r);
  9.         Thread t1 = new Thread(pro); 
  10.         Thread t2 = new Thread(con);
  12.         t1.start();
  13.         t2.start();
  14.     }
  16. }
  17. class Resource {
  18.     private String name;
  19.     private int count = 1;
  20.     private boolean flag = false;
  22.     public synchronized void set(String name) {
  23.         if(flag) {
  24.             try {
  25.                 this.wait();
  26.             } catch (InterruptedException e) {
  28.             }
  29.         }
  30.         this.name = name+"--"+count++;
  31.         System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
  32.         flag = true;
  33.         this.notify();
  34.     }
  35.     public synchronized void out() {
  36.         if(!flag) {
  37.             try {
  38.                 wait();
  39.             } catch (InterruptedException e) {
  41.             }
  42.         }
  43.         System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
  44.         flag = false;
  45.         notify();
  46.     }
  47. }
  48. class Producer implements Runnable {
  49.     private Resource res;
  50.     Producer(Resource res) {
  51.         this.res = res;
  52.     }
  54.     public void run() {
  55.         while(true) {
  56.             res.set("+商品+");
  57.         }
  58.     }
  59. }
  60. class Consumer implements Runnable {
  61.     private Resource res;
  62.     Consumer(Resource res) {
  63.         this.res = res;
  64.     }
  65.     public void run() {
  66.         while(true) {
  67.             res.out();
  68.         }
  69.     }
  70. }

运行以上代码是只有一个生成者和一个消费者，当有多个生产者和多个消费者时，会产生异常情况：即重复生产或重复消费。
生产者和消费者（多个）

  1. class ProducerConsumerDemo {
  2.     public static void main(String[] args) {
  3.         Resource r = new Resource();
  4.         Producer pro = new Producer(r);
  5.         Consumer con = new Consumer(r);
  6.         Thread t1 = new Thread(pro);
  7.         Thread t2 = new Thread(pro);
  8.         Thread t3 = new Thread(con);
  9.         Thread t4 = new Thread(con);
  10.         t1.start();
  11.         t2.start();
  12.         t3.start();
  13.         t4.start();
  14.     }
  15. }
  16. class Resource {
  17.     private String name;
  18.     private int count = 1;
  19.     private boolean flag = false;
  21.     public synchronized void set(String name) {
  22.         while(flag)
  23.             try { this.wait(); } catch(Exception e) {}
  24.         this.name = name+"--"+count++;
  25.         System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
  26.         flag = true;
  27.         this.notifyAll();
  28.     }
  29.     public synchronized void out() {
  30.         while(!flag)
  31.             try { this.wait(); } catch(Exception e) {}
  32.         System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
  33.         flag = false;
  34.         this.notifyAll();
  35.     }
  36. }
  37. class Producer implements Runnable {
  38.     private Resource res;
  39.     Producer(Resource res) {
  40.         this.res = res;
  41.     }
  42.     public void run() {
  43.         while(true) {
  44.             res.set("+商品+");
  45.         }
  46.     }
  47. }
  48. class Consumer implements Runnable {
  49.     private Resource res;
  50.     Consumer(Resource res) {
  51.         this.res = res;
  52.     }
  53.     public void run() {
  54.         while(true) {
  55.             res.out();
  56.         }
  57.     }
  58. }

对于多个生产者和消费者，为什么一定要定义while判断标记？
原因：让被唤醒的线程再一次判断标记。
为什么定义notifyAll？
原因：因为需要唤醒对方线程，因为只用notify，容易出现只唤醒本方线程的情况，导致程序中的所有线程都等待。
JDK1.5版本中提供了多线程的升级解决方案。

  1. 将同步synchronized替换成了显示的Lock操作。
  2. 将Object中的wait/notify/notifyAll替换成Condition对象。该对象可以通过Lock锁进行获取。

该示例实现了本方只唤醒对方的操作

  1. import java.util.concurrent.locks.*;
  3. class ProducerConsumerDemo2 {
  4.     public static void main(String[] args) {
  5.         Resource r = new Resource();
  6.         Producer pro = new Producer(r);
  7.         Consumer con = new Consumer(r);
  8.         Thread t1 = new Thread(pro);
  9.         Thread t2 = new Thread(pro);
  10.         Thread t3 = new Thread(con);
  11.         Thread t4 = new Thread(con);
  12.         t1.start();
  13.         t2.start();
  14.         t3.start();
  15.         t4.start();
  16.     }
  17. }
  18. class Resource {
  19.     private String name;
  20.     private int count = 1;
  21.     private boolean flag = false;
  23.     private Lock lock = new ReentrantLock();
  24.     // 返回绑定到此Lock实例的新Condition实例，Lock可以支持多个相关的Condition对象
  25.     private Condition condition_pro = lock.newCondition();
  26.     private Condition condition_con = lock.newCondition();
  28.     public void set(String name) throws InterruptedException {
  29.         lock.lock();
  30.         try {
  31.             while(flag)
  32.                 condition_pro.await(); // 抛出异常
  33.             this.name = name+"--"+count++;
  34.             System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
  35.             flag = true;
  36.             condition_con.signal(); // 唤醒某一个消费者 
  37.         } finally {
  38.             lock.unlock(); // 释放锁资源的动作一定要执行
  39.         }
  40.     }
  41.     public void out() throws InterruptedException {
  42.         lock.lock();
  43.         try {
  44.             while(!flag)
  45.                 condition_con.await(); // 抛出异常
  46.             System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
  47.             flag = false;
  48.             condition_pro.signal(); // 唤醒某一个生产者
  49.         } finally {
  50.             lock.unlock();
  51.         }
  52.     }
  53. }
  54. class Producer implements Runnable {
  55.     private Resource res;
  56.     Producer(Resource res) {
  57.         this.res = res;
  58.     }
  59.     public void run() {
  60.         while(true) {
  61.             try {
  62.                 res.set("+商品+");
  63.             } catch(InterruptedException e) {
  65.             }
  66.         }
  67.     }
  68. }
  69. class Consumer implements Runnable {
  70.     private Resource res;
  71.     Consumer(Resource res) {
  72.         this.res = res;
  73.     }
  74.     public void run() {
  75.         while(true) {
  76.             try {
  77.                 res.out();
  78.             } catch(InterruptedException e) {
  80.             }
  81.         }
  82.     }
  83. }

面试时，可能会问生产者与消费者有什么替代方案呢？
答：JDK1.5版本提供了显示的锁机制，以及显示的锁对象上的等待唤醒操作机制。同时将等待唤醒进行了封装，封装完，一个锁对应多个Condition对象，之前一个锁对应一个Condition对象。

停止线程

如何停止线程？
stop()已经过时，只有一种，即run()结束。
开启多线程运行，运行代码通常都是循环结构。只要控制住循环，就可以让run()结束，也就是线程结束。
例，

  1. class StopThread implements Runnable {
  2.     private boolean flag = true;
  3.     public void run() {
  4.         while(flag) {
  5.             System.out.println(Thread.currentThread().getName()+"....run");
  6.         }
  7.     }
  8.     public void changeFlag() {
  9.         flag = false;
  10.     }
  11. }
  12. class StopThreadDemo {
  13.     public static void main(String[] args) {
  14.         StopThread st = new StopThread();
  15.         Thread t1 = new Thread(st);
  16.         Thread t2 = new Thread(st);
  18.         t1.start();
  19.         t2.start();
  21.         int num = 0;
  22.         while(true) {
  23.             if(num++ == 60) {
  24.                 st.changeFlag();
  25.                 break;
  26.             }
  27.             System.out.println(Thread.currentThread().getName()+"........."+num);
  28.         }
  29.         System.out.println("over");
  30.     }
  31. }

特殊情况：当线程处于了冻结状态，就不会读取到标记，那么线程就不会结束。即：

  1. class StopThread implements Runnable {
  2.     private boolean flag = true;
  3.     public synchronized void run() {
  4.         while(flag) {
  5.             try {
  6.                 wait();
  7.             } catch(InterruptedException e) {
  8.                 System.out.println(Thread.currentThread().getName()+"....exception");
  9.             }
  10.             System.out.println(Thread.currentThread().getName()+"....run");
  11.         }
  12.     }
  13.     public void changeFlag() {
  14.         flag = false;
  15.     }
  16. }
  17. class StopThreadDemo {
  18.     public static void main(String[] args) {
  19.         StopThread st = new StopThread();
  20.         Thread t1 = new Thread(st);
  21.         Thread t2 = new Thread(st);
  23.         t1.start();
  24.         t2.start();
  26.         int num = 0;
  27.         while(true) {
  28.             if(num++ == 60) {
  29.                 st.changeFlag();
  30.                 break;
  31.             }
  32.             System.out.println(Thread.currentThread().getName()+"........."+num);
  33.         }
  34.         System.out.println("over");
  35.     }
  36. }

当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除，强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。Thread类中提供了该方法：interrupt()。

  1. class StopThread implements Runnable {
  2.     private boolean flag = true;
  3.     public synchronized void run() {
  4.         while(flag) {
  5.             try {
  6.                 wait();
  7.             } catch(InterruptedException e) {
  8.                 System.out.println(Thread.currentThread().getName()+"....exception");
  9.                 flag = false;
  10.             }
  11.             System.out.println(Thread.currentThread().getName()+"....run");
  12.         }
  13.     }
  14.     public void changeFlag() {
  15.         flag = false;
  16.     }
  17. }
  18. class StopThreadDemo {
  19.     public static void main(String[] args) {
  20.         StopThread st = new StopThread();
  21.         Thread t1 = new Thread(st);
  22.         Thread t2 = new Thread(st);
  24.         t1.start();
  25.         t2.start();
  27.         int num = 0;
  28.         while(true) {
  29.             if(num++ == 60) {
  30.                 st.changeFlag();
  31.                 t1.interrupt();
  32.                 t2.interrupt();
  33.                 break;
  34.             }
  35.             System.out.println(Thread.currentThread().getName()+"........."+num);
  36.         }
  37.         System.out.println("over");
  38.     }
  39. }

线程类的其他方法

  1. class StopThread implements Runnable {
  2.     private boolean flag = true;
  3.     public synchronized void run() {
  4.         while(flag) {
  5.             try {
  6.                 wait();
  7.             } catch(InterruptedException e) {
  8.                 System.out.println(Thread.currentThread().getName()+"....exception");
  9.                 flag = false;
  10.             }
  11.             System.out.println(Thread.currentThread().getName()+"....run");
  12.         }
  13.     }
  14.     public void changeFlag() {
  15.         flag = false;
  16.     }
  17. }
  18. class StopThreadDemo {
  19.     public static void main(String[] args) {
  20.         StopThread st = new StopThread();
  21.         Thread t1 = new Thread(st);
  22.         Thread t2 = new Thread(st);
  24.         t1.setDaemon(true);
  25.         t2.setDaemon(true);
  27.         t1.start();
  28.         t2.start();
  30.         int num = 0;
  31.         while(true) {
  32.             if(num++ == 60) {
  33.                 break;
  34.             }
  35.             System.out.println(Thread.currentThread().getName()+"........."+num);
  36.         }
  37.         System.out.println("over");
  38.     }
  39. }
  1. class Demo implements Runnable {
  2.     public void run() {
  3.         for (int x = 0; x < 70; x++) {
  4.             System.out.println(Thread.currentThread().toString()+"...."+x);
  5.         }
  6.     }
  7. }
  8. class JoinDemo {
  9.     public static void main(String[] args) throws Exception {
  10.         Demo d = new Demo();
  11.         Thread t1 = new Thread(d);
  12.         Thread t2 = new Thread(d);
  13.         t1.start();
  14.         // t1.setPriority(Thread.MAX_PRIORITY); //设置进程优先级，默认为5
  15.         t2.start();
  16.         t1.join(); // 主线程冻结
  17.         for (int x = 0; x < 80; x++) {
  18.             System.out.println("main...."+x);
  19.         }
  20.         System.out.println("over");
  21.     }
  22. }
  1. class Demo implements Runnable {
  2.     public void run() {
  3.         for (int x = 0; x < 70; x++) {
  4.             System.out.println(Thread.currentThread().toString()+"...."+x);
  5.             Thread.yield(); //将CPU的执行权释放出去，作用：让线程都有平均运行的机会
  6.         }
  7.     }
  8. }
  9. class JoinDemo {
  10.     public static void main(String[] args) throws Exception {
  11.         Demo d = new Demo();
  12.         Thread t1 = new Thread(d);
  13.         Thread t2 = new Thread(d);
  14.         t1.start();
  15.         t2.start();
  16.         t1.join(); // 主线程冻结
  17.         for (int x = 0; x < 80; x++) {
  18.             System.out.println("main...."+x);
  19.         }
  20.         System.out.println("over");
  21.     }
  22. }

实际开发时，怎么使用多线程呢？
以下例进行讲解，假设main()里有3段循环代码运行。可用多线程来实现（代码如下）：

  1. class ThreadTest1 {
  2.     public static void main(String[] args) {
  3.         new Thread() {
  4.             public void run() {
  5.                 for(int x = 0; x < 100; x++) {
  6.                     System.out.println(Thread.currentThread().getName()+"....."+x);
  7.                 }
  8.             }
  9.         }.start();
  11.         for(int x = 0; x < 100; x++) {
  12.             System.out.println(Thread.currentThread().getName()+"....."+x);
  13.         }
  15.         Runnable r = new Runnable() {
  16.             public void run() {
  17.                 for(int x = 0; x < 100; x++) {
  18.                     System.out.println(Thread.currentThread().getName()+"....."+x);
  19.                 }
  20.             }
  21.         };
  22.         new Thread(r).start();
  23.     }
  24. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注