JAVA多线程编程实践

Lock & Synchronized

    lock与synchronized都可以实现线程同步。但是

    1) Lock提供了可定时tryLock(long, TimeUnit)，可轮询（try lock()）、可中断lockInterruptibly()的锁获取操作、公平队列等功能。

    2) 性能上lock会比synchronized相对来说要好点（java5会好很多）。

    3) Lock提供了Condition，对线程的等待和唤醒等操作更加灵活，一个ReentrantLock可以有多个Condition实例，所以更有扩展性。

   

    lock不足：

   1)  lock 必须在 finally 块中释放.否则如果在受保护块出现异常，锁将永远不会释放。

 

   2)  java6之前 synchronized与ReentrantLock相比：线程转储能够显示哪些个调用框架调用了哪些锁，能够识别死锁发生的线程。然而Lock 类只是普通的类，JVM 不知道具体哪个线程拥有 Lock 对象。

 

trylock、lockInterruptibly

    引用https://www.zhihu.com/question/36771163/answer/68974735

    1.public void lock()

  获取锁。

  如果该锁没有被另一个线程保持，则获取该锁并立即返回，将锁的保持计数设置为 1。

  如果当前线程已经保持该锁，则将保持计数加 1，并且该方法立即返回。

  如果该锁被另一个线程保持，则出于线程调度的目的，禁用当前线程，并且在获得锁之前，   该线程将一直处于休眠状态，此时锁保持计数被设置为 1。

 2.lockInterruptibly

  public void lockInterruptibly() throws InterruptedException

  1）如果当前线程未被中断，则获取锁。

  2）如果该锁没有被另一个线程保持，则获取该锁并立即返回，将锁的保持计数设置为 1。

  3）如果当前线程已经保持此锁，则将保持计数加 1，并且该方法立即返回。

  4）如果锁被另一个线程保持，则出于线程调度目的，禁用当前线程，并且在发生以下两种情况之一以前，该线程将一直处于休眠状态：

  1>.锁由当前线程获得；或者

  2>.其他某个线程中断当前线程。

  5）如果当前线程获得该锁，则将锁保持计数设置为 1。 如果当前线程：

  1>.在进入此方法时已经设置了该线程的中断状态；或者

  2>.在等待获取锁的同时被中断。

则抛出 InterruptedException，并且清除当前线程的已中断状态。

  6）在此实现中，因为此方法是一个显式中断点，所以要优先考虑响应中断，而不是响应锁的普通获取或重入获取。

  3.tryLock

  public boolean tryLock()

  仅在调用时锁未被另一个线程保持的情况下，才获取该锁。

  1）如果该锁没有被另一个线程保持，并且立即返回 true 值，则将锁的保持计数设置为     1。 即使已将此锁设置为使用公平排序策略，但是调用 tryLock() 仍将 立即获取锁（如    果有可用的）， 而不管其他线程当前是否正在等待该锁。在某些情况下，此“闯入”行    为可能很有用，即使它会打破公 平性也如此。如果希望遵守此锁的公平设置，则使用     tryLock(0, TimeUnit.SECONDS) ，它几乎是等效的（也检测中断）。

  2）如果当前线程已经保持此锁，则将保持计数加 1，该方法将返回 true。

  3）如果锁被另一个线程保持，则此方法将立即返回 false 值。

 

Lock Condition使用

 

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


public class ConditionTest {
	public static void main(String[] args) {
		Container container = new Container();
		
		new Thread(new Producer(container)).start();
		new Thread(new Consumer(container)).start();
	}
}

class Container{
	private int MAX_SIZE = 5;
	private List<Integer> list = new ArrayList<>();
	Lock lock = new ReentrantLock();
	Condition notFull = lock.newCondition();
	Condition notEmpty = lock.newCondition();
	
	public void put(int num){
		lock.lock();
		try {
			while(list.size() == MAX_SIZE){
				System.out.println("容器已满。");
				notFull.await();
			}
			
			list.add(num);
			System.out.println("容器放入了一个数：" + num +" 容器内数值："+list.toString());
			notEmpty.signal();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
	public void get(){
		lock.lock();
		try {
			while(list.size() == 0){
				System.out.println("容器为空");
				notEmpty.await();
			}
			int num = list.get(0);
			list.remove(0);
			System.out.println("容器移除第一个数："+num +" 容器内数值："+list.toString());
			notFull.signal();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
}

class Producer implements Runnable{
	
	private Container container;
	
	public Producer(Container container) {
		this.container = container;
	}

	@Override
	public void run() {
		for(int j=0;j<10;j++){
			try {
				Thread.sleep(100);
				int num = new Random().nextInt(100);
				container.put(num);
			} catch (InterruptedException e) {
			}
		}
	}
}

class Consumer implements Runnable{
	
	private Container container;
	
	public Consumer(Container container) {
		this.container = container;
	}

	@Override
	public void run() {
		for(int j=0;j<10;j++){
			try {
				Thread.sleep(200);
				container.get();
			} catch (InterruptedException e) {
				// TODO: handle exception
			}
		}
	}
}

 

读写锁

  读写锁实现的加锁策略读读不互斥，读写互斥，写写互斥。

  它允许多个读者并发的访问被保护对象，当访问多为读取数据的时候，他具有可改进伸缩性的潜力(JAVA并发编程实践)

  这里直接用网上的一段代码阐述其用法：

  

import java.util.Random;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockTest {
	public static void main(String[] args) {
		final Queue3 q3 = new Queue3();
		for(int i=0;i<3;i++)
		{
			new Thread(){
				public void run(){
					while(true){
						q3.get();                        
					}
				}

			}.start();
		}
		for(int i=0;i<3;i++)
		{        
			new Thread(){
				public void run(){
					while(true){
						q3.put(new Random().nextInt(10000));
					}
				}            

			}.start();    
		}
	}
}

class Queue3{
	private Object data = null;//共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。
	private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
	public void get(){
		rwl.readLock().lock();//上读锁，其他线程只能读不能写
		System.out.println(Thread.currentThread().getName() + " be ready to read data!");
		try {
			Thread.sleep((long)(Math.random()*1000));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName() + "have read data :" + data);        
		rwl.readLock().unlock(); //释放读锁，最好放在finnaly里面
	}

	public void put(Object data){

		rwl.writeLock().lock();//上写锁，不允许其他线程读也不允许写
		System.out.println(Thread.currentThread().getName() + " be ready to write data!");                    
		try {
			Thread.sleep((long)(Math.random()*1000));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.data = data;        
		System.out.println(Thread.currentThread().getName() + " have write data: " + data);                    

		rwl.writeLock().unlock();//释放写锁    
	}
}