生产者和消费者

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

复制代码

多个生产者和消费者

• 对于多个生存者消费者，为什么要定义while标志？
  唤醒线程后再判定一次flag
• 为什么定义notifyAll?
  唤醒对方线程，因为只用notify，容易出现只唤醒本方线程情况，导致程序所有线程等待。
  

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

复制代码

java.util.concurrent.locks
只唤醒对方。

1. import java.util.concurrent.locks.Condition;
   
2. import java.util.concurrent.locks.Lock;
   
3. import java.util.concurrent.locks.ReentrantLock;
   
4. public class Res {
   
5.     private String name;
   
6.     private int count=1;
   
7.     private boolean flag=false;
   
8.     private Lock lock=new ReentrantLock();
   
9.     private Condition condition= lock.newCondition();
   
10.     public  void set(String name) throws InterruptedException{
    
11.         lock.lock();
    
12.         try{
    
13.         while(flag){
    
14.             condition.await();
    
15.         }
    
16.         this.name=name+"---"+count++;
    
17.         System.out.println(Thread.currentThread().getName()+"--生产者--"+this.name);
    
18.         flag=true;
    
19.         condition.signalAll();
    
20.         }finally{
    
21.         lock.unlock();}
    
22.     }
    
23.     public  void out()throws InterruptedException{
    
24.         lock.lock();
    
25.         try{
    
26.         while(!flag){
    
27.             condition.await();
    
28.         }
    
29.         System.out.println(Thread.currentThread().getName()+"--消费者------"+this.name);
    
30.         flag=false;
    
31.         condition.signalAll();
    
32.         }finally{
    
33.         lock.unlock();}
    
34.     }
    
35.     public static void main(String []args){
    
36.         Res r=new Res();
    
37.         Producer pro=new Producer(r);
    
38.         Consumer con=new Consumer(r);
    
39.         Thread t1=new Thread(pro);
    
40.         Thread t2=new Thread(pro);
    
41.         Thread t3=new Thread(con);
    
42.         Thread t4=new Thread(con);
    
43.         t1.start();
    
44.         t2.start();
    
45.         t3.start();
    
46.         t4.start();
    
47.     }
    
48. }
    
49. class Producer implements Runnable{
    
50.     private Res res;
    
51.     Producer(Res res){
    
52.         this.res=res;
    
53.     }
    
54.     @Override
    
55.     public void run() {
    
56.         while(true){
    
57.             try {
    
58.             res.set("+商品+");
    
59.             }catch(InterruptedException e){
    
60.                 e.printStackTrace();
    
61.             }
    
62.         }
    
63.     }
    
64. }
    
65. class Consumer implements Runnable{
    
66.     private Res res;
    
67.     Consumer(Res res){
    
68.         this.res=res;
    
69.     }
    
70.     @Override
    
71.     public void run() {
    
72.         while(true){
    
73.             try {
    
74.             res.out();
    
75.             }catch(InterruptedException e){
    
76.                 e.printStackTrace();
    
77.             }
    
78.         }
    
79.     }
    
80. }
    

复制代码

停止线程

开启多线程运行，通常代码是循环结构，只要控制循环，就可以让RUN方法结束。结束线程。特殊情况，当线程处于冻结状态，就不会读取到标记，线程不会结束。
interrupt()方法强制清除冻结状态。这样可以操作标记让线程结束。

1. public class StopThread implements Runnable {
   
2.     private boolean flag=true;
   
3.     @Override
   
4.     public synchronized void run() {
   
5.         while(flag){
   
6.             try{
   
7.                 wait();
   
8.             }catch(InterruptedException e){
   
9.                 e.printStackTrace();
   
10.                 flag=false;
    
11.                 }
    
12.             }
    
13.         System.out.println(Thread.currentThread().getName()+"----run");
    
14.     }
    
15.     public void changeFlag(){
    
16.         flag=false;
    
17.     }
    
18.     public static void main(String[]args){
    
19.         Thread t=new Thread(new StopThread());
    
20.         t.start();
    
21.         t.interrupt();
    
22.     }
    
23. }
    

复制代码

守护线程

setDeamon(true)//标记线程为守护线程（后台线程）。主线程是前台线程，当所有前台线程结束后，后台线程自动结束。

1.     public static void main(String[]args){
   
2.         Thread t=new Thread(new StopThread());
   
3.               t.setDeamon(true);
   
4.         t.start();
   
5.         t.interrupt();
   

复制代码

join()方法

new Thread(r).join()//该线程抢夺执行权，让主线程冻结。
当A线程执行到B线程join()方法时，A就会等待，等B线程执行完，A线程才会执行。
join用来临时加入线程执行。

优先级和yield

谁开启线程，线程就属于哪个组。例如main线程组
优先级1-10，通常是5
t.setPriority(Thread.MAX_PRIORITY)

yield，暂停当前线程对象，执行其他线程。
Thread.yield();//临时施放线程资源。平均运行效果。

毕向东老师视频知识点笔记---多线程（1）

支持，用心了，加油

毕老师的视频真不错

最好代码上加注释啊！！这样过一段时或者别人看起来不直观啊。。。。。。。。。。

路途 发表于 2015-7-6 18:39
最好代码上加注释啊！！这样过一段时或者别人看起来不直观啊。。。。。。。。。。 ...

都是小例子，逻辑很简单。这些例子都是对代码前面知识点说明。