Java并发03之线程通信

1 经典卖票案例

1.1 案例描述

如今有100张火车票，两个窗口同时售卖：

public class SaleTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        Thread t1 = new Thread(ticket, "窗口1");
        Thread t2 = new Thread(ticket, "窗口2");
        Thread t3 = new Thread(ticket, "窗口3");

        t1.start();
        t2.start();
        t3.start();
    }

    static class Ticket implements Runnable {
        private int ticket = 100;

        @Override
        public void run() {
            String name = Thread.currentThread().getName();
            do {
                sell(name);
            } while (ticket > 0);
        }

        private void sell(String name) {
            if (ticket > 0) {
                System.out.println(name + "卖票：" + ticket);
                ticket--;
            }
        }
    }
}

原因分析：因为多线程是CPU随机执行的，当线程一执行输出语句时，还未执行ticket--时就跳转到线程二，此时就会出现数据没有及时更新、同时售卖同一张票的情况。

1.2 同步代码块

对需要连续执行的代码加一把锁，称为同步代码块。代码代码块中的代码必须执行完才会切换到其他线程，这样就能保证了线程之间的安全。synchronized (同步监视器(也就是锁))，任何一个类的对象都可以充当锁。要求：多个线程共用一把锁。

private void sell(String name) {
    synchronized (this) {
        if (ticket > 0) {
            System.out.println(name + "卖票：" + ticket);
            ticket--;
        }
    }
}

1.3 同步方法

private synchronized void sell(String name) {
    if (ticket > 0) {
        System.out.println(name + "卖票：" + ticket);
        ticket--;
    }
}

2 线程通信

2.1 概念

Java支持多个线程同时访问一个共享变量，共享变量是存储在共享内存的，每个线程在本地内存拥有这个变量的拷贝，所以一个线程看到的变量并不一定是最新的。volatile关键字可以用来解决这一问题，它能保证所有线程对变量访问的可见性。

但是，过多地使用volatile是不必要的，因为它会降低程序执行的效率。而多线程之间的正确的通信方式能够避免对同一共享变量的争夺。

2.2 通信方式

2.2.1 wait()/notify()

• 调用wait前一定要获得同步锁，如果在调用前没有获得同步锁，程序会抛出异常。
• 调用notify的线程如果和调用wait的线程获得的不是同一把锁，notify不起作用。
• wait和notify的执行顺序不能颠倒，这在编码上会造成一定的难度。

public class Clerk {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        new Producer(clerk, "生产者1").start();
        new Consumer(clerk, "消费者1").start();
    }

    // 共享资源
    private int productCount = 0;

    public synchronized void produce() throws InterruptedException {
        if (productCount < 20) {
            System.out.println(Thread.currentThread().getName() + "：开始生产第" + ++productCount + "个产品");
            notify();   // 生产完成，通知消费者线程来生产
        } else {
            wait(); // 太多产品滞销了，睡一会
        }
    }

    public synchronized void consume() throws InterruptedException {
        if (productCount > 0) {
            System.out.println(Thread.currentThread().getName() + "：开始消费第" + productCount-- + "个产品");
            notify();   // 消费完成，通知生产者线程来生产
        } else {
            wait(); // 没有产品了，睡一会
        }
    }

    static class Producer extends Thread {
        private final Clerk clerk;

        public Producer(Clerk clerk, String name) {
            this.clerk = clerk;
            currentThread().setName(name);
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "：开始生产产品。。。");
            while (true) {
                try {
                    Thread.sleep(500);
                    clerk.produce();
                } catch (InterruptedException ignored) {
                }
            }
        }
    }

    static class Consumer extends Thread {
        private final Clerk clerk;

        public Consumer(Clerk clerk, String name) {
            this.clerk = clerk;
            currentThread().setName(name);
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "：开始消费产品。。。");
            while (true) {
                try {
                    Thread.sleep(1000);
                    clerk.consume();
                } catch (InterruptedException ignored) {
                }
            }
        }
    }
}

2.2.2 await()/signal()

尽管这种方式相对于wait()有了一定改进，但仍存在类似的缺点：

• 调用await前一定要获得同步锁，如果在调用前没有获得锁，程序会抛出异常。
• await和signal的执行顺序不能颠倒。

public class Number {
    private int count;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void incry() throws InterruptedException {
        try {
            lock.lock();
			  // 睡一会	
            while (count != 0) {
                condition.await();
            }
			  // 操作资源
            count++;
            System.out.println(Thread.currentThread().getName() + "加一成功，count值为：" + count);
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void decry() throws InterruptedException {
        try {
            lock.lock();
            while (count == 0) {
                condition.await();
            }
            count--;
            System.out.println(Thread.currentThread().getName() + "减一成功，count值为：" + count);
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

2.2.3 park()/unpark()

​ LockSupport定义了一组的公共静态方法，这些方法提供了最基本的线程阻塞和唤醒功能。可以使用park来阻塞线程，以及unpark(Thread thread)方法来唤醒一个被阻塞的线程。优点：

• 以线程为操作对象更直观地阻塞线程。
• 相比notify随机唤醒一个线程，unpark能够更精准地唤醒一个线程。

park/unpark的设计原理核心是“许可”：park是等待一个许可，unpark是为某线程提供一个许可。如果某线程A调用park，那么除非另外一个线程调用unpark(A)给A一个许可，否则线程A将阻塞在park操作上。但是这个“许可”是不能叠加的，“许可”是一次性的。比如线程B连续调用了三次unpark函数，当线程A调用park函数就使用掉这个“许可”，如果线程A再次调用park，则进入等待状态。

public static void main(String[] args) {
	Thread t1 = new Thread(() -> {
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {            }
		System.out.println(Thread.currentThread().getName() + "\t ----come in ");
		LockSupport.park();
		System.out.println(Thread.currentThread().getName() + "\t ----被唤醒 ");
	}, "t1");
	t1.start();

	// 即使先调用unpark，也可以正常执行
	try {
		TimeUnit.SECONDS.sleep(1);
	} catch (InterruptedException e) {        }

	new Thread(() -> {
		LockSupport.unpark(t1);
		System.out.println(Thread.currentThread().getName() + "\t ----发出通知 ");
	}, "t2").start();
}

2.2.4 BlockingQueue

public class Clerk {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(10);
        new Thread(new Producer(queue),"生产者1").start();
        new Thread(new Consumer(queue),"消费者1").start();
        new Thread(new Consumer(queue),"消费者2").start();
    }
    
	static class Producer implements Runnable {

        private BlockingQueue<String> clerk;

        public Producer(BlockingQueue<String> clerk) {
            this.clerk = clerk;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "：开始生产产品。。。");
            while (true) {
                try {
                    Thread.sleep(300);
                    String product = UUID.randomUUID().toString().substring(0, 4);
                    clerk.put(product);
                    System.out.println(Thread.currentThread().getName() + "：生产了；" + product);
                } catch (InterruptedException ignored) {                }
            }
        }
	}

	static class Consumer implements Runnable {

        private BlockingQueue<String> clerk;

        public Consumer(BlockingQueue<String> clerk) {
            this.clerk = clerk;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "：开始消费产品。。。");
            while (true) {
                try {
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + "：消费了：" + clerk.take());
                } catch (InterruptedException ignored) {                }
            }
        }
    }
}