引言
本文主要描述，Java中多线程共享数据（同步）/线程死锁/生产者与消费者应用案例。
多线程的优势：资源利用率好、程序设计在某种情况下更简单、程序响应更快。
进程和线程之间如何通信：进程间通讯依靠 IPC 资源，例如管道（pipes）、套接字（sockets）等；线程间通讯依靠 JVM 提供的 API，例如 wait()、notify()、notifyAll() 等方法，线程间还可以通过共享的主内存来进行值的传递。
多线程共享数据（同步）
线程同步：多个线程在同一个时间段只能有一个线程执行其指定代码，其他线程要等待此线程完成之后才可以继续执行。
多线程共享数据的安全问题，使用同步解决。
创建一个多线程：同步方式按照如下所示
public static void main(String[] args) {
MyThread s0 = new MyThread();
Thread t1 = new Thread(s0,"one");
Thread t2 = new Thread(s0,"two");
t1.start();
t2.start();
}
同步代码块
使用方式：synchronized(要同步的对象){ 要同步的操作 }
class MyThread implements Runnable{
Object obj = new Object(); //同步的标记对象
@Override
public void run() {
//同步代码块
synchronized(obj){
System.out.println(Thread.currentThread().getName()+" is doing...");
try {
Thread.sleep(1000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" finished.");
}
}
}
同步方法
使用方式：public synchronized void method(){ 要同步的操作 }，同步的是当前对象(this)
public synchronized void doMethod(){
System.out.println(Thread.currentThread().getName()+" is doing...");
try {
Thread.sleep(1000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" finished.");
}
线程死锁
当一个对象内，同步过多，会造成斯死锁。
定义一个服务员类：Waiter，其下有两个同步方法
public class Waiter {
public synchronized void say(Customer c) {
System.out.println("Waiter: Pay --> Do");
c.doService();
}
public synchronized void doService() {
System.out.println("Waiter: OK");
}
}
定义一个消费者类：Customer，其下有两个同步方法
public class Customer {
public synchronized void say(Waiter w) {
System.out.println("Customer: Do --> Pay");
w.doService();
}
public synchronized void doService() {
System.out.println("Customer: OK");
}
}
当同时访问的时候，就会造成数据死锁。
public class Main {
public static void main(String[] args) {
new MyThred();
}
}
class MyThred implements Runnable {
Customer c = new Customer();
Waiter w = new Waiter();
public MyThred() {
new Thread(this).start();
w.say(c);
}
@Override
public void run() {
c.say(w);
}
}
总结：当 synchronized 用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。
生产者与消费者应用案例
案例需求：生产者不断生成产品，消费者不断取走产品。
创建共享资源类
package lib; /** * 共享资源类 */ public class Storage { private String type; private String date; private boolean isEmpty = true; /** * 生产者向共享资源存储数据 * @param type * @param date */ public synchronized void push(String type, String date) { try { while (!isEmpty) { // 当前共享资源状态不为空，等待消费者消费 this.wait(); } // 生产开始 this.type = type; Thread.sleep(10); this.date = date; // 生产结束 isEmpty = false; this.notifyAll(); } catch (InterruptedException e) { e.printStackTrace(); } } /** * 消费者从共享资源中取出数据，并打印 */ public synchronized void popup() { try { while (isEmpty) { //当资源为空，释放同步锁，进入等待 this.wait(); } Thread.sleep(10); //消费开始 System.out.println(this.type + "-->" + this.date); //消费结束 isEmpty = true; this.notifyAll(); } catch (InterruptedException e) { e.printStackTrace(); } } }
创建生产者类
package lib; /** * 生产者 */ public class Producer implements Runnable { private Storage storage; public Producer(Storage storage) { this.storage = storage; } @Override public void run() { for (int i = 0; i < 20; i++) { if (i%2==0) { storage.push("apple", "20190625001"); } else { storage.push("banana", "20190625002"); } } } }
创建消费者类
package lib;
public class Consumer implements Runnable {
private Storage storage;
public Consumer(Storage storage) {
this.storage = storage;
}
@Override
public void run() {
for (int i=0;i<20;i++) {
storage.popup();
}
}
}
执行测试：两个生产者，两个消费者
package lib;
public class Test {
public static void main(String[] args) {
Storage storage = new Storage();
Producer p1 = new Producer(storage);
Producer p2 = new Producer(storage);
Consumer c1 = new Consumer(storage);
Consumer c2 = new Consumer(storage);
Thread t1 = new Thread(p1, "P1");
Thread t2 = new Thread(p2, "P2");
Thread t3 = new Thread(c1, "C1");
Thread t4 = new Thread(c2, "C2");
t1.start();
t2.start();
t3.start();
t4.start();
}
}
总结说明：
wait():执行该方法的线程对象释放同步锁,JVM把该线程存放到等待池中,等待其他的线程唤醒该线程。
notify:执行该方法的线程唤醒在等待池中等待的任意一个线程,把线程转到锁池中等待。
notifyAll():执行该方法的线程唤醒在等待池中等待的所有的线程,把线程转到锁池中等待。
使用lock
wait和notify方法,只能被同步监听锁对象来调用,否则报错IllegalMonitorStateException。那么现在问题来了,Lock机制根本就没有同步锁了,也就没有自动获取锁和自动释放锁的概念。因为没有同步锁,所以Lock机制不能调用wait和notify方法。解决方案:Java5中提供了Lock机制的同时提供了处理Lock机制的通信控制的Condition接口。
从Java5开始,可以:
1):使用Lock机制取代synchronized 代码块和synchronized 方法。
2):使用Condition接口对象的await,signal,signalAll方法取代Object类中的wait,notify,notifyAll方法。
package lib; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 共享资源类 */ public class Storage { private String type; private String date; private boolean isEmpty = true; private final Lock lock = new ReentrantLock(); private Condition condition = lock.newCondition(); /** * 生产者向共享资源存储数据 * @param type * @param date */ public void push(String type, String date) { lock.lock(); //获取对象锁 try { while (!isEmpty) { // 当前共享资源状态不为空，等待消费者消费 condition.await(); } // 生产开始 this.type = type; Thread.sleep(10); this.date = date; // 生产结束 isEmpty = false; condition.signalAll(); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); //释放对象锁 } } /** * 消费者从共享资源中取出数据，并打印 */ public void popup() { lock.lock(); try { while (isEmpty) { //当资源为空，释放同步锁，进入等待 condition.await(); } Thread.sleep(10); //消费开始 System.out.println(this.type + "-->" + this.date); //消费结束 isEmpty = true; condition.signalAll(); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } }
synchronized和lock的区别
- 都是锁。解决线程安全问题
- synchronized无法判断是否获得锁的状态，而lock可以判断
- synchronized只能通过线程执行完之后释放，而lock可以手动释放
- synchronized是关键字，而lock是接口
- synchronized范围是整个方法或代码块，而lock是调用的方式，灵活性更好
- synchronized会一直等待线程，不能响应中断，而lock可以