Java_基础—多线程之间的通信以及JDK1.5新特性互斥锁

一、什么时候需要通信

• 多个线程并发执行时, 在默认情况下CPU是随机切换线程的
• 如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印

二、怎么通信

• 如果希望线程等待, 就调用wait()
• 如果希望唤醒等待的线程, 就调用notify();
• 这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用

package com.soar.thread;

import java.util.TimerTask;

public class Demo4_Notify {
    /*
     * 等待唤醒机制
     */
    public static void main(String[] args) {
        final Printer p = new Printer();

        new Thread(){
            public void run(){
                while(true){
                    try {
                        p.print1();
                    } catch (Exception e) {

                        e.printStackTrace();
                    }
                }
            }
        }.start();

        new Thread(){
            public void run(){
                while(true){
                    try {
                        p.print2();
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }

}

//等待唤醒机制
class Printer {
    private int flag = 1;
    public  void print1() throws Exception{     
        synchronized(this){
            if(flag !=1){
                this.wait();                //当前线程等待
            }
            System.out.print("S");
            System.out.print("o");
            System.out.print("a");
            System.out.print("r");
            System.out.println();
            flag = 2;
            this.notify();                  //随机唤醒单个等待的线程
        }
    }
    public void print2() throws InterruptedException{   
        synchronized(this){     //锁对象不能用匿名对象，因为匿名对象不是同一个对象
            if(flag != 2){
                this.wait();
            }
            System.out.print("S");
            System.out.print("i");
            System.out.print("r");
            System.out.println();
            flag = 1;
            this.notify();
        }
    }
}

Console:

Soar
Sir
Soar
Sir
Soar
Sir
Soar
Sir
Soar
Sir
Soar
Sir
.........

三、三个或三个以上间的线程通信

多个线程通信的问题

• notify()方法是随机唤醒一个线程
• notifyAll()方法是唤醒所有线程
• JDK5之前无法唤醒指定的一个线程
• 如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件

wait()，notify()，sleep()方法的注意事项：

1、在同步代码块中使用什么对象当作锁，就用什么对象去调用wait()方法

2、为什么wait()方法和notify()方法定义在Object这个类中呢？

• 因为锁对象可以是任意对象，Object是所有类的基类，所以wait()方法和notify()方法需要定义在Object这个类中

3、sleep()方法和wait()方法的区别？

• sleep方法必须传入参数，参数就是时间，时间到了自动醒来
• wait方法可以传入参数，也可以不传入参数，传入参数就是在参数的时间结束后等待，不传入参数就是直接等待
• sleep方法在同步函数或同步代码块中，不释放锁（睡着了也抱着锁睡，因为它在指定的时间会醒来）
• wait方法在同步函数或者同步代码块中，释放锁

package com.soar.thread;

public class Demo5_NotifyAll {

    public static void main(String[] args) {
        final Printer2 p = new Printer2();

        new Thread(){
            public void run(){
                while(true){
                    try {
                        p.print1();
                    } catch (Exception e) {

                        e.printStackTrace();
                    }
                }
            }
        }.start();

        new Thread(){
            public void run(){
                while(true){
                    try {
                        p.print2();
                    } catch (Exception e) {

                        e.printStackTrace();
                    }
                }
            }
        }.start();

        new Thread(){
            public void run(){
                while(true){
                    try {
                        p.print3();
                    } catch (Exception e) {

                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }

}
//等待唤醒机制
class Printer2 {
    private int flag = 1;
    public  void print1() throws Exception{     
        synchronized(this){
            while(flag !=1){
                this.wait();            //当前线程等待
            }
            System.out.print("S");
            System.out.print("o");
            System.out.print("a");
            System.out.print("r");
            System.out.println();
            flag = 2;
            //this.notify();                    //随机唤醒单个等待的线程
            this.notifyAll();                   //唤醒所有的，谁满足条件，就谁来
        }
    }
    public void print2() throws InterruptedException{   
        synchronized(this){     //锁对象不能用匿名对象，因为匿名对象不是同一个对象
            while(flag != 2){
                this.wait();            //线程2在此等待
            }
            System.out.print("S");
            System.out.print("i");
            System.out.print("r");
            System.out.println();
            flag = 3;
            //this.notify();
            this.notifyAll();
        }
    }

    public void print3() throws InterruptedException{   
        synchronized(this){     //锁对象不能用匿名对象，因为匿名对象不是同一个对象
            while(flag != 3){   
                this.wait();            //线程3在此等待，if语句是在哪里等待，就在哪里起来
                                        //while循环是循环判断，每次都会判断标记
            }
            System.out.print("H");
            System.out.print("e");
            System.out.print("l");
            System.out.print("l");
            System.out.print("o");
            System.out.println();
            flag = 1;
            //this.notify();
            this.notifyAll();
        }
    }
}

四、JDK1.5新特性互斥锁替代以上代码

1、同步
使用ReentrantLock类的lock()和unlock()方法进行同步

2、通信

• 使用ReentrantLock类的newCondition()方法可以获取Condition对象
• 需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
• 不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了

package com.soar.thread;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Demo6_ReentrantLock {

    public static void main(String[] args) {
        final Printer3 p = new Printer3();

        new Thread(){
            public void run(){
                try {
                    p.print1();
                } catch (Exception e) {

                    e.printStackTrace();
                }
            }
        }.start();

        new Thread(){
            public void run(){
                try {
                    p.print2();
                } catch (Exception e) {

                    e.printStackTrace();
                }
            }
        }.start();

        new Thread(){
            public void run(){
                try {
                    p.print3();
                } catch (Exception e) {

                    e.printStackTrace();
                }
            }
        }.start();
    }

}
class Printer3 {
    private ReentrantLock r = new ReentrantLock();
    private Condition c1 = r.newCondition();
    private Condition c2 = r.newCondition();
    private Condition c3 = r.newCondition();
    private int flag = 1;
    public  void print1() throws Exception{     
        r.lock();
            if(flag !=1){
                c1.await();
            }
            System.out.print("S");
            System.out.print("o");
            System.out.print("a");
            System.out.print("r");
            System.out.println();
            flag = 2;
            //this.notify();                    //随机唤醒单个等待的线程
            c2.signal();
        r.unlock();
        }

    public void print2() throws InterruptedException{   
        r.lock();
            if(flag != 2){
                c2.await();
            }
            System.out.print("S");
            System.out.print("i");
            System.out.print("r");
            System.out.println();
            flag = 3;
            //this.notify();
            c3.signal();
        r.unlock();
        }


    public void print3() throws InterruptedException{   
        r.lock();
            if(flag != 3){  
                c3.await();
                                        //while循环是循环判断，每次都会判断标记
            }
            System.out.print("H");
            System.out.print("e");
            System.out.print("l");
            System.out.print("l");
            System.out.print("o");
            System.out.println();
            flag = 1;
            //this.notify();
            c1.signal();
        r.unlock();
    }
}

Console：

Soar
Sir
Hello
Soar
Sir
Hello
Soar
Sir
Hello
Soar
Sir
Hello
..........