多线程之间的数据通讯方法

多线程之间的数据通讯方法

生产者消费者模式

生产/消费者问题是个非常典型的多线程问题,涉及到的对象包括生产者、消费者、仓库和产品。他们之间的关系如下:

  • 生产者仅仅在仓储未满时候生产,仓满则停止生产。
  • 消费者仅仅在仓储有产品时候才能消费,仓空则等待。
  • 当消费者发现仓库没产品可消费时候会通知生产者生产。
  • 生产者在生产出可消费产品时候,应该通知等待的消费者去消费。

编码实现

仓库类,产品就是仓库的属性data

//临界资源
public class Basket {
	private volatile Object data;
	//生产者向仓库中存放数据
	public synchronized void product(Object data) {
		//如果仓库中有数据,则生产者进入阻塞等待,直到其它线程唤醒
		while(this.data!=null)
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		//如果没有数据则进行生产操作
		this.data=data;
		System.out.println(Thread.currentThread().getName()+"生产了一个日期"+this.data);
		this.notifyAll();//唤醒在当前对象上处于wait的所有线程
	}
	//消费者从仓库中消费数据
	public synchronized void consume() {
		//如果仓库中没有数据,则消费者进入阻塞等待,直到其它线程唤醒
		while(this.data==null)
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		//如果有数据data!=null,则执行消费操作
		System.out.println(Thread.currentThread().getName()+"消费了一个数据"+this.data);
		this.data=null;
		this.notifyAll();  //唤醒在当前对象上处于wait的所有线程
	}
}

生产者线程负责生产产品,并和消费者共享仓库

public class Producer extends Thread {
	private Basket basket;
	//通过构造器传入对应的basket对象
	public Producer(Basket basket) {
		this.basket=basket;
	}
	@Override
	public void run() {
		//生产20次日期对象
		for(int i=0;i<20;i++) {
			Object data=new Date();  //生产者生产的具体产品
			basket.product(data);
		}
	}
}

消费者线程负责消费产品,并和生产者共享仓库

public class Consumer extends Thread {
	private Basket basket;

	public Consumer(Basket basket) {
		this.basket = basket;
	}

	@Override
	public void run() {
		// 消费20次日期对象
		for (int i = 0; i < 20; i++) {
			basket.consume();
		}
	}
}

生产者和消费者在同一时间段内共用同一个存储空间,生产者往存储空间中添加产品,消费者从存储空间中取走产品,当存储空间为空时,消费者阻塞,当存储空间满时,生产者阻塞。

为什么要使用生产者/消费者模式

在线程世界里,生产者就是生产数据的线程,消费者就是消费数据的线程。在多线程开发当中,如果生产者处理速度很快,而消费者处理速度很慢,那么生产者就必须等待消费者处理完,才能继续生产数据。同样的道理,如果消费者的处理能力大于生产者,那么消费者就必须等待生产者。为了解决这种生产消费能力不均衡的问题,所以便有了生产者和消费者模式。

生产者/消费者模型优点

1、解耦。因为多了一个缓冲区,所以生产者和消费者并不直接相互调用,这一点很容易想到,这样生产者和消费者的代码发生变化,都不会对对方产生影响,这样其实就把生产者和消费者之间的强耦合解开,变为了生产者和缓冲区/消费者和缓冲区之间的弱耦合

2、通过平衡生产者和消费者的处理能力来提高整体处理数据的速度,这是生产者/消费者模型最重要的一个优点。如果消费者直接从生产者这里拿数据,如果生产者生产的速度很慢,但消费者消费的速度很快,那消费者就得占用CPU的时间片白白等在那边。有了生产者/消费者模型,生产者和消费者就是两个独立的并发体,生产者把生产出来的数据往缓冲区一丢就好了,不必管消费者;消费者也是,从缓冲区去拿数据就好了,也不必管生产者,缓冲区满了就不生产,缓冲区空了就不消费,使生产者/消费者的处理能力达到一个动态的平衡

生产者/消费者模式的作用

  • 支持并发
  • 解耦
  • 支持忙闲不均

调用wait/notify之类的方法要求必须在当前线程对象内部,例如synchronized方法中

单例模式Singleton

保证在VM中只有一个实例

  • 饿汉模式
    • 私有构造器
    • 私有的静态属性 private static Singleton instance=new Singleton();
    • 共有的静态方法
  • 懒汉模式
    • 私有构造器
    • 私有的静态属性,不直接创建对象
    • 共有的静态方法
public class Singleton {
	private Singleton() {}
	private static Singleton instance;
	public static Singleton getInstance() {
		if(instance==null)
			instance=new Singleton();   //当第一次使用对象时才进行创建
		return instance;
	}
}

有可能会有对象的多次创建,如何解决

public class Singleton {
	private Singleton() {}
	private static Singleton instance;
	public synchronized static Singleton getInstance() {
		if(instance==null)
			instance=new Singleton();   //当第一次使用对象时才进行创建
		return instance;
	}
}

一般不建议使用颗粒度较大的锁处理机制,并发性会受到影响

双检测的懒汉模式

  • 按需创建对象,避免没有用处的创建操作

  • 线程安全

public class Singleton{ 
    private Singleton(){}
    private static Singleton instance=null;
    public static Singleton getInstance(){
    	if(instance==null){
    		synchronized(Singleton.class){
    			if(instance==null)
    	    	    instance=new Singleton();
    	    }
    	 }   
        return instance;
    }
}

Lock的使用

Lock是java 1.5中引入的线程同步工具,它主要用于多线程下共享资源的控制。本质上Lock仅仅是一个接口,可以通过显式定义同步锁对象来实现同步,能够提供比synchronized更广泛的锁定操作,并支持多个相关的Condition对象

  • void lock();尝试获取锁,获取成功则返回,否则阻塞当前线程

void lockInterruptibly() throws InterruptedException;尝试获取锁,线程在成功获取锁之前被中断,则放弃获取锁,抛出异常

boolean tryLock();尝试获取锁,获取锁成功则返回true,否则返回false

boolean tryLock(long time, TimeUnit unit)尝试获取锁,若在规定时间内获取到锁,则返回true,否则返回false,未获取锁之前被中断,则抛出异常

  • void unlock();释放锁
  • Condition newCondition();返回当前锁的条件变量,通过条件变量可以实现类似notify和wait的功能,一个锁可以有多个条件变量

Lock有三个实现类,一个是ReentrantLock,另两个是ReentrantReadWriteLock类中的两个静态内部类ReadLock和WriteLock。

使用方法:多线程下访问(互斥)共享资源时, 访问前加锁,访问结束以后解锁,解锁的操作推荐放入finally块中。

private final ReentrantLock lock=new ReentrantLock();

在具体方法中lock.lock() try{}finally{lock.unlock}

Lock lock=new ReentrantLock();//构建锁对象
try{
	lock.lock();//申请锁,如果可以获取锁则立即返回,如果锁已经被占用则阻塞等待
	System.out.println(lock);//执行处理逻辑
} finally{
	lock.unlock();//释放锁,其它线程可以获取锁
}

样例1:启动4个线程,对一个int数字进行各50次加减操作,要求2个加,2个减,保证输出的线程安全

public class OperNum {
	private int num=0;	
	private final static Lock lock=new ReentrantLock();  //构建锁对象
	public void add() {
		try {
			lock.lock();  //申请加锁操作,如果能加上则立即返回,否则阻塞当前线程
			num++;
			System.out.println(Thread.currentThread().getName()+"add..."+num);
		} finally {
			lock.unlock(); //具体实现采用的是重入锁,所以持有锁的线程可以多次申请同一个锁,但是申请加锁次数必须和释放锁的次数一致
		}
	}
	public void sub() {
		try {
			lock.lock();
			num--;
			System.out.println(Thread.currentThread().getName()+"sub..."+num);
		} finally {
			lock.unlock();
		}
	}
}

Condition接口

Condition是j.u.c包下提供的一个接口。可以翻译成 条件对象,其作用是线程先等待,当外部满足某一条件时,在通过条件对象唤醒等待的线程。

void await() throws InterruptedException;让线程进入等待,如果其他线程调用同一Condition对象的notify/notifyAll,那么等待的线程可能被唤醒。释放掉锁

void signal();唤醒等待的线程

void signalAll();唤醒所有线程

使用Condition的特殊点:

  • 当调用condition.await()阻塞线程时会自动释放锁,不管调用了多少次lock.lock(),这时阻塞在lock.lock()方法上线程则可以获取锁
  • 当调用condition.signal()唤醒线程时会继续上次阻塞的位置继续执行,默认会自动重新获取锁(注意和阻塞时获取锁的次数一致)
已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页