文章目录
前言
1、synchronized 关键字修饰方法或代码段,只保证临界数据是互斥访问的
2、volatile修饰变量
3、ReentrantLock可重入锁，实现数据的互斥访问
4、wait和notify，实现线程间的等待通知机制
5、ReentrantLock结合Condition接口，实现线程间的等待通知机制
前言
java多线程同步和通信的方法有如下几种：
1.synchronized关键字修饰方法或代码段，实现数据的互斥访问
2.volatile修饰变量，实现多线程环境下数据的同步
3.ReentrantLock可重入锁，实现数据的互斥访问
4.synchronized结合Object的wait和notify方法，实现线程间的等待通知机制
5.ReentrantLock结合Condition接口的await()和signal()方法，实现线程间的等待通知机制
1、synchronized 关键字修饰方法或代码段,只保证临界数据是互斥访问的
java的每个对象都有一个内置锁，当用synchronized关键字修饰时，线程会获取该对象的内置锁，其他线程没有获取该对象的内置锁就会进入阻塞状态。
对象锁: synchronized关键字修饰代码段时，需要传入一个对象，通过该对象的内置锁来实现代码块的同步。
synchronized关键字修饰方法时，会将实例化的java对象的内置锁传进去，通过该锁来实现代码块的同步。
类锁: synchronized关键字修饰静态方法，会锁住该类的Class对象，此时如果调用该静态方法，将会锁住整个类。
注意: 同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。
package com.kgc; /** * @author：Tokgo J * @date：2020/2/23 * @aim： */ public class Demo1 { static class MyThread extends Thread{ Bank bank; public MyThread(String 线程, Bank bank){ this.bank=bank; } @Override public void run(){ for(int i=0;i<10;i++){ bank.save(100); // 多线程调用该同步方法 } } } static class Bank{ private int account = 100 ; // 临界数据 public int getAccount(){ return account; } // 同步方法 public synchronized void save(int money){ account+=money; System.out.println("当前线程："+Thread.currentThread().getId()+"当前余额："+getAccount()); } public void save1(int money){ //同步代码块 synchronized (this){ // 获取当前对象锁 account+=money; System.out.println("当前线程："+Thread.currentThread().getId()+"当前余额："+getAccount()); } } } public static void main(String[] args) { Bank bank = new Bank(); MyThread th1 = new MyThread("线程1",bank); th1.start(); MyThread th2 = new MyThread("线程2",bank); th2.start(); } }
2、volatile修饰变量
使用 volatile 修饰域相当于告诉虚拟机该域可能会被其他线程更新，因此可以保证在多线程环境下保证数据的一致性
class Bank { //需要同步的变量加上volatile private volatile int account = 100; public int getAccount() { return account; } //这里不再需要synchronized public void save(int money) { account += money; } ｝
3、ReentrantLock可重入锁，实现数据的互斥访问
class Bank{ private ReentrantLock lock = new ReentrantLock(); private int account = 100;//临界区数据 public int getAccount(){ return account; } public void put(int money) { lock.lock(); try { account+=money; System.out.println(Thread.currentThread().getId()+"存入"+money+" 当前余额:"+getAccount()); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } public void get(int money) { lock.lock(); try { account-=money; System.out.println(Thread.currentThread().getId()+"取出"+money+" 当前余额:"+getAccount()); } catch (InterruptedException e) { e.printStackTrace(); } finally{ lock.unlock(); } } }
4、wait和notify，实现线程间的等待通知机制
通常在synchronized修饰的代码块中使用wait、notify/notifyAll函数。
当wait()被执行的时,会释放当前所持有的锁,然后让出CPU,进入等待阻塞状态；
当notify/notifyAll()被执行时候,会唤醒一个或多个正处于等待状态的线程,然后继续往下执行,因此最好在同步代码块最后执行notify / notifyAll。
//消费者线程类,每隔100ms消费一个产品 class CustomerThread extends Thread{ Bank bank; public CustomerThread(Bank bank) { this.bank = bank; } @Override public void run() { while(true){ bank.get(1); try { sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } } //生产者线程类,每隔300ms生产一个产品 class ProductorThread extends Thread{ Bank bank; public ProductorThread(Bank bank) { this.bank = bank; } @Override public void run() { while(true){ bank.put(1); try { sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } } } } //数据缓冲区 class Bank{ private int account = 100;//临界区数据 public int getAccount(){ return account; } public void put(int money){ synchronized(this) //获取当前对象锁 { if(getAccount() >= 120){ //若数量大于120则阻塞当前线程,释放对象锁 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } account+=money;//生产一个产品 System.out.println(Thread.currentThread().getId()+"存入"+money+" 当前余额:"+getAccount()); this.notifyAll();//唤醒其他线程 } } public void get(int money){ synchronized(this) { if(getAccount() <= 0){ // 若数量小于等于0则阻塞当前线程，释放对象锁 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } account-=money; // 消费一个产品 System.out.println(Thread.currentThread().getId()+"取出"+money+" 当前余额:"+getAccount()); this.notifyAll();//唤醒其他线程 } } } //主函数调用例子 public static void main(String[] args) { Bank bank = new Bank();//创建一个缓冲区对象 ProductorThread th1 = new ProductorThread(bank);//创建生产者线程1 th1.start(); ProductorThread th2 = new ProductorThread(bank);//创建生产者线程2 th2.start(); CustomerThread th3 = new CustomerThread(bank);//创建消费者线程1 th3.start(); }
5、ReentrantLock结合Condition接口，实现线程间的等待通知机制
class CustomerThread extends Thread{ Bank bank; public CustomerThread(Bank bank) { this.bank = bank; } @Override public void run() { while(true){ bank.get(1); try { sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } } class ProductorThread extends Thread{ Bank bank; public ProductorThread(Bank bank) { this.bank = bank; } @Override public void run() { while(true){ bank.put(1); try { sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } } } } class Bank{ private ReentrantLock lock = new ReentrantLock(); // 创建可重入锁 private Condition notEmpty = lock.newCondition(); // 创建非空条件变量 private Condition notFullCondition = lock.newCondition(); // 创建非满条件变量 private int account = 100;//临界区数据 public int getAccount(){ return account; } public void put(int money){ lock.lock(); try { if(getAccount() >= 120){ //当数量已满时，等待非满条件 notFullCondition.await(); } //进行生产 account+=money; System.out.println(Thread.currentThread().getId()+"存入"+money+" 当前余额:"+getAccount()); notEmpty.signal();// 非空条件释放信号 } catch (InterruptedException e) { e.printStackTrace(); } finally{ lock.unlock(); } } public void get(int money){ lock.lock(); try { if(getAccount() <= 0){ //当数量为空时，等待非空条件 notEmpty.await(); } // 进行消费 account-=money; System.out.println(Thread.currentThread().getId()+"取出"+money+" 当前余额:"+getAccount()); notFullCondition.signal();// 非满条件释放信号 } catch (InterruptedException e) { e.printStackTrace(); } finally{ lock.unlock(); } } } public static void main(String[] args) { Bank bank = new Bank(); ProductorThread th1 = new ProductorThread(bank); th1.start(); CustomerThread th3 = new CustomerThread(bank); th3.start(); }
