开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> Lock接口和锁 -> 正文阅读

[Java知识库]Lock接口和锁

1 Lock接口

JDK5加入，与synchronized比较，显示定义，结构更灵活。
提供更多实用性方法，功能更强大、性能更优越。（同步锁、互斥锁）

常用方法:
void lock() //获取锁，如锁被占用，则等待。
boolean tryLock() //尝试获取锁（成功返回true。失败返回false，不阻塞）。
void unlock() //释放锁。

2 重入锁

所谓重入锁，指的是以线程为单位，当一个线程获取对象锁之后，这个线程可以再次获取本对象上的锁，而其他的线程是不可以的。
synchronized 和 ReentrantLock 都是可重入锁。（参考API）
可重入锁的意义在于防止死锁。

ReentrantLock：Lock接口的实现类，与synchronized一样具有互斥锁功能。

示例案例1（多个线程向数组中添加数据）

/**
 * 1、重入锁
 *    ReentrantLock：Lock接口的实现类，与synchronized一样具有互斥锁功能。    
 */
class TestMyList {
	 private Lock lock = new ReentrantLock();
	 private String[] strs = {"A","B","","",""};	
     private int count = 2;
     public void add(String val){
    	 lock.lock();//上锁
    	 try {
			strs[count] = val;
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			count++;
			System.out.println(Thread.currentThread().getName()+"添加了数据："+val);
		} finally {
			lock.unlock();//释放锁
		}
     }
 
     public String[] getStr(){
    	    return strs;
     }
}

/**
 * 需求：准备两个任务，创建两个线程，同时向数组中插入元素
 */
public class MyList {
	public static void main(String[] args) throws InterruptedException {
		final TestMyList list = new TestMyList();
         //创建两个线程
		Runnable runnable1 = new Runnable(){
			@Override
			public void run() {
				list.add("hello");
			}
		};
		Runnable runnable2 = new Runnable(){
			@Override
			public void run() {
				list.add("world");
			}
		};		
		//
		Thread th1 = new Thread(runnable1);
		Thread th2 = new Thread(runnable2);

		th1.start();
		th2.start();

		//此处 join方法比较重要，影响执行的顺序，表示执行完线程后，才往下继续执行
		th1.join();
		th2.join();
		
		System.out.println(Arrays.toString(list.getStr()));
	}
}

示例案例2（4个窗口卖火车票）

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


class Ticket implements Runnable{
	private int ticket = 100;
	private Lock lock = new ReentrantLock();
	@Override
	public void run() {
        while(true){
        	lock.lock();
        	try {
        		if(ticket <= 0){
            		break;
            	}
         System.out.println(Thread.currentThread().getName()+"卖了第"+ticket+"张票");
            	ticket--;
			} finally {
				lock.unlock();
			}
        }		
	}
}
/**
 * 测试
 */
public class TestTicket {
	public static void main(String[] args) {
		Ticket ticket = new Ticket();
		ExecutorService es = Executors.newFixedThreadPool(4);
		for (int i = 0; i < 4; i++) {
			es.submit(ticket);
		}
		es.shutdown();
	}
}

可重入锁可以参考以下链接：https://blog.csdn.net/yanyan19880509/article/details/52345422.

2 读写锁

ReentrantReadWriteLock implements ReadWriteLock（查看jdk API）
一种支持一写多读的同步锁，读写分离，可分别分配读锁、写锁。
支持多次分配读锁，使多个读操作可以并发执行。

互斥规则
写-写：互斥，阻塞
读-写：互斥，读阻塞写、写阻塞读
读-读：不互斥、不阻塞。（效率高）可以采用异步方式

读写锁在读操作远远高于写操作的环境中，可在保障线程安全的情况下，提高运行效率。

示例案例1（演示读写锁使用，4秒左右）

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;
/**
 * 演示 读写锁 使用
 * @author enbo
 * @date 2020年7月26日
 */
class ReadWriteDemo {
	private String val;
	//创建读写锁
	ReentrantReadWriteLock rrw = new ReentrantReadWriteLock();
	//获取读锁
	private ReadLock readLock = rrw.readLock();
	//获取写锁
	private WriteLock writeLock = rrw.writeLock();
	//写入
	public void setVal(String val){
		//使用写锁上锁
		writeLock.lock();
		try {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+" 写入："+val);
			this.val = val;
		} finally {
			writeLock.unlock();
		}
	}
	//读取
	public String getVal(){
		//使用读锁上锁
		readLock.lock();
		try {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+" 读取："+this.val);
			return this.val;
		} finally{
			readLock.unlock();
		}
	}
}

/**
 * 测试 读写锁
 * 注意：使用读写锁，测试的时候 交换  读写代码块的顺序，效率不同
 */
public class Test {
	public static void main(String[] args) {
		//
		final ReadWriteDemo readWriteDemo = new ReadWriteDemo();
		//创建线程池  20个线程
		ExecutorService es = Executors.newFixedThreadPool(20);
		
		Runnable readRunnable = new Runnable(){
			@Override
			public void run() {
				readWriteDemo.getVal();
			}
		};
		
		Runnable writeRunnable = new Runnable(){
			@Override
			public void run() {
				readWriteDemo.setVal("Hello"+new Random().nextInt(100));
			}
		};
		long start = System.currentTimeMillis();
		//分配 2个写任务 （读写交换顺序位置 先读后写、再 先写后读）  同步
		for (int i = 0; i < 2; i++) {
			es.submit(writeRunnable);
		}
		//分配 18个读取任务    异步
		for (int i = 0; i < 18; i++) {
			es.submit(readRunnable);
		}
		
		es.shutdown();
		//es.isTerminated(); 为true表示所有任务完成，线程池关闭
		while(!es.isTerminated()){

		}
		
		long end = System.currentTimeMillis();
		//先读后写     用时：3003 
		//先写后读     用时：4003
		System.out.println("用时："+(end-start));
	}
}

示例案例2（演示互斥锁使用，20秒左右）

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 换成  互斥锁   测试比较
 * 使用 互斥锁，不管是读还是写，每一步都相互排斥，效率比较低
 */
class ReadWriteDemo {
	private String val;

	private ReentrantLock lock = new ReentrantLock();
	
	//写入
	public void setVal(String val){
		//使用写锁上锁
		lock.lock();
		try {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+" 写入："+val);
			this.val = val;
		} finally {
			lock.unlock();
		}
	}
	//读取
	public String getVal(){
		//使用读锁上锁
		lock.lock();
		try {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+" 读取："+this.val);
			return this.val;
		} finally{
			lock.unlock();
		}
	}
}
/**
 * 测试 互斥锁（测试代码不变，ReadWriteDemo 换成互斥锁）
 * 注意：使用互斥锁，测试的时候 交换  读写代码块的顺序，效率变化不大
 */
public class Test2 {
	public static void main(String[] args) {
		//
		final ReadWriteDemo readWriteDemo = new ReadWriteDemo();
		//创建线程池  20个线程
		ExecutorService es = Executors.newFixedThreadPool(20);
		
		Runnable readRunnable = new Runnable(){
			@Override
			public void run() {
				readWriteDemo.getVal();
			}
		};
		
		Runnable writeRunnable = new Runnable(){
			@Override
			public void run() {
				readWriteDemo.setVal(" Hello "+new Random().nextInt(100));
			}
		};
		long start = System.currentTimeMillis();
		//分配 2个写任务  （互斥锁  交换读写顺序，时间没有影响）
		for (int i = 0; i < 2; i++) {
			es.submit(writeRunnable);
		}
		//分配 18个读取任务  
		for (int i = 0; i < 18; i++) {
			es.submit(readRunnable);
		}
		
		es.shutdown();
		//es.isTerminated(); 为true表示所有任务完成，线程池关闭
		while(!es.isTerminated()){
			
		}
		
		long end = System.currentTimeMillis();
	    
		System.out.println("用时："+(end-start));
	}
}

boolean isTerminated()
若关闭后所有任务都已完成，则返回true。注意除非首先调用shutdown或shutdownNow，否则isTerminated永不为true。

3 线程安全的集合

线程安全集合介绍

Collection体系集合、以及线程安全集合。

在这里插入图片描述

Collections工具类中提供了多个可以获得线程安全集合的方法。
public static Collection synchronizedCollection(Collection c)
public static List synchronizedList(List list)
public static Set synchronizedSet(Set s)
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
public static SortedSet synchronizedSortedSet(SortedSet s)
public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)

4 CopyOnWriteArrayList

import java.util.ArrayList;
/**
 * 集合线程安全问题演示
 * ArrayList 非线程安全的集合
 * 产生异常信息：
 * java.util.ConcurrentModificationException  并发修改异常
 */
public class Demo1 {
	public static void main(String[] args) {
		//1、创建ArrayList   线程不安全
		ArrayList list = new ArrayList();
		//2、创建线程
		for (int i = 0; i < 20; i++) {
			int temp = i;
			new Thread(new Runnable(){
				@Override
				public void run() {
					for (int j = 0; j < 10; j++) {
						list.add(Thread.currentThread().getName()+"======"+temp+"====="+j);
					    System.out.println(list.toString());
					    System.out.println("--------");
					}
				}
			}).start();
		}
	}
}

Exception in thread "Thread-18" --------java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
	at java.util.ArrayList$Itr.next(ArrayList.java:851)
	at java.util.AbstractCollection.toString(AbstractCollection.java:461)
	at Demo1$1.run(Demo1.java:20)
	at java.lang.Thread.run(Thread.java:745)

集合线程不安全问题解决方案

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 集合线程安全问题演示
 * ArrayList  线程非安全集合
 * 产生异常信息：
 * java.util.ConcurrentModificationException  并发修改异常
 * 
 * 解决1：使用Collections中的线程安全方法转成线程安全的集合
 *      Collections.synchronizedList(List);
 *      在jdk1.5之前，我们使用这种方式
 */
public class Demo2 {
	public static void main(String[] args) {
		//1、创建ArrayList
		ArrayList list1 = new ArrayList();
		//使用Collections中的线程安全方法转成线程安全的集合
		List list = Collections.synchronizedList(list1);
		
		//2、创建线程
		for (int i = 0; i < 20; i++) {
			int temp = i;
			new Thread(new Runnable(){
				@Override
				public void run() {
					for (int j = 0; j < 10; j++) {
			list.add(Thread.currentThread().getName()+"======"+temp+"====="+j);
					    System.out.println(list.toString());
					}
				}
			}).start();
		}
      try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("元素个数："+list.size());
		for (Object str:list) {
			System.out.println(str);
		}
	}
}

CopyOnWriteArrayList 特点

线程安全的ArrayList,加强版读写分离。
写有锁，读无锁，读写之间不阻塞,优于读写锁。
写入时，先copy一个容器副本、再添加新元素,最后替换引用。
使用方式与ArrayList无异。

public class TestCopyOnWriteArrayList {
	public static void main(String[] args) {
		List<String> list = new CopyOnWriteArrayList<String>();
	}
}

特点：以空间换取性能，缺点是比较耗费空间。

import java.util.concurrent.CopyOnWriteArrayList;

/**
 * 集合线程安全问题演示
 * ArrayList  线程非安全集合
 * 产生异常信息：
 * java.util.ConcurrentModificationException  并发修改异常
 * 解决2：在jdk1.5及以后
 * 使用 CopyOnWriteArrayList<String>
 * 
 */
public class Demo3 {

	public static void main(String[] args) {
		//1、创建ArrayList
		//ArrayList list1 = new ArrayList();
		//使用Collections中的线程安全方法转成线程安全的集合
		//List list = Collections.synchronizedList(list1);
		//解决2：在jdk1.5及以后 ,使用 CopyOnWriteArrayList
		CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
		
		//2、创建线程
		for (int i = 0; i < 5; i++) {
			int temp = i;
			new Thread(new Runnable(){
				@Override
				public void run() {
					for (int j = 0; j < 10; j++) {
			list.add(Thread.currentThread().getName()+"======"+temp+"====="+j);
					    System.out.println(list.toString());
					}
				}
			}).start();
		}
	}
}

注意：结果可能没有产生50个数据，因为在输出最终结果的时候，可能线程还没结束！


import java.util.Random;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
使用多线程操作   CopyOnWriteArrayList
需求：使用多线程，向集合中添加数据。
 boolean isTerminated()
  若关闭后所有任务都已完成，则返回true。注意除非首先调用shutdown或shutdownNow，否则isTerminated永不为true。
 返回：若关闭后所有任务都已完成，则返回true。
 */
public class Demo4 {
	public static void main(String[] args) {
		//1、创建CopyOnWriteArrayList
		CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
		//2、使用多线程操作
		ExecutorService es = Executors.newFixedThreadPool(5);
		//3、提交任务
		for (int i = 0; i < 5; i++) {
			es.submit(new Runnable() {
				@Override
				public void run() {
					for (int j = 0; j < 10; j++) {
	list.add(Thread.currentThread().getName()+"..."+new Random().nextInt(1000));
					}
				}
			});
		}
	   //4、关闭线程池
		es.shutdown();
		// isTerminated
		while(!es.isTerminated()) {
		}
		//5、打印结果
		System.out.println("元素个数："+list.size());
		for (String str:list) {
			System.out.println(str);
		}
	}
}

CopyOnWriteArrayList 源碼

    final void setArray(Object[] a) {
        array = a;
    }

    /**
     * Creates an empty list.
     */
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

5 CopyOnWriteArraySet示例代码

import java.util.concurrent.CopyOnWriteArraySet;

/**
 * CopyOnWriteArraySet
 *     特点：唯一、有序       底层是 CopyOnWriteArrayList
 *     判断重复的依据：equals() 
 */
public class Demo5 {
   public static void main(String[] args) {
	 //1、创建集合
	 CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<String>();
	 //2、添加元素
	 set.add("apple");
	 set.add("huawei");
	 set.add("xiaomi");
	 set.add("lenovo");
	 set.add("apple");
	 //3、输出
	 System.out.println("元素个数："+set.size());
	 System.out.println(set.toString());
   }
}

CopyOnWriteArraySet源碼

public class CopyOnWriteArraySet<E> extends AbstractSet<E>
        implements java.io.Serializable {
    private static final long serialVersionUID = 5457747651344034263L;

    private final CopyOnWriteArrayList<E> al;

    /**
     * Creates an empty set.
     */
    public CopyOnWriteArraySet() {
        al = new CopyOnWriteArrayList<E>();
    }

    /**
     * Creates a set containing all of the elements of the specified
     * collection.
     *
     * @param c the collection of elements to initially contain
     * @throws NullPointerException if the specified collection is null
     */
    public CopyOnWriteArraySet(Collection<? extends E> c) {
        if (c.getClass() == CopyOnWriteArraySet.class) {
            @SuppressWarnings("unchecked") CopyOnWriteArraySet<E> cc =
                (CopyOnWriteArraySet<E>)c;
            al = new CopyOnWriteArrayList<E>(cc.al);
        }
        else {
            al = new CopyOnWriteArrayList<E>();
            al.addAllAbsent(c);
        }
    }

线程安全的Set,底层使用CopyOnWriteArrayList实现。
唯一不同在于，使用addIfAbsent()添加元素,会遍历数组，
如存在元素,则不添加(扔掉副本)

6 ConcurrentHashMap

简单理解为线程安全的HashMap
初始容量默认为16段(Segment) ，使用分段锁设计
不对整个Map加锁，而是为每个Segment加锁
当多个对象存入同-个Segment时,才需要互斥
最理想状态为1 6个对象分别存入16个Segment,并行数量16
使用方式与HashMap无异

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class TestConcurrentHashMap {
	public static void main(String[ ] args) {
		Map<String,String> map = new ConcurrentHashMap<String, String>();
	}
}

注意：jdk1.8后，Oracle对ConcurrentHashMap做了调整，不再采用分段锁设计方式，而采用的是无锁算法（CAS）。
参考链接：https://www.cnblogs.com/williamjie/p/9099861.html.

ConcurrentHashMap示例代码

import java.util.concurrent.ConcurrentHashMap;
/**
 *初始容量默认为16段（Segment），使用分段锁设计。
 *不对整个Map加锁，而是为每个Segment加锁。
 *当多个对象存入同一个Segment时，才需要互斥。
 *最理想状态为16个对象分别存入16个Segment，并行数量16。
 *使用方式与HashMap无异。
 *说明：ConcurrentHashMap 在jdk1.7及之前，采用的是分段锁设计。在jdk1.8及之后，Oracle采用的是CAS无锁设计，效率更高。
 */
public class Demo6 {
	public static void main(String[] args) {
		//1创建集合
ConcurrentHashMap<String, String> hashMap=new ConcurrentHashMap<String, String>();
		//2使用多线程添加数据
		for(int i=0;i<5;i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					for(int k=0;k<10;k++) {
						hashMap.put(Thread.currentThread().getName()+"--"+k, k+"");
						System.out.println(hashMap);
					}
				}
			}).start();
		}
	}
}

7 Queue接口(Collection的子接口，表示队列FIFO（First In First Out）。)

常用方法:
抛出异常:

boolean add(E e) //顺序添加-个元素(到达上限后，再添加则会抛出异常)
E remove() //获得第一一个元素井移除(如果队列没有元素时，则抛异常)
E element() //获得第- -个元素但不移除(如果队列没有元素时，则抛异常)

返回特殊值:推荐使用

boolean offer(E e) //顺序添加- -个元素 (到达上限后，再添加则会返回false)
E poll() //获得第一个元素并移除(如果队列没有元素时，则返回null)
E keep( //获得第- 个元素但不移除 (如果队列没有元素
示例代码

import java.util.LinkedList;
import java.util.Queue;

/**
 * Queue：Collection的子接口，表示队列FIFO（First In First Out）。
 * LinkedList 实现了  Queue接口，但是线程不安全。
 */
public class Demo7 {
	public static void main(String[] args) {
		//1创建队列
		Queue<String> queue=new LinkedList<>();
		//2入队
		queue.offer("苹果");
		queue.offer("橘子");
		queue.offer("葡萄");
		queue.offer("西瓜");
		queue.offer("榴莲");
		//3出队
		System.out.println(queue.peek());
		System.out.println("----------------");
		System.out.println("元素个数:"+queue.size());
		int size=queue.size();
		for(int i=0;i<size;i++) {
			System.out.println(queue.poll());
		}
	   System.out.println("出队完毕:"+queue.size());
	}
}

注意：LinkedList 是线程不安全的，如果需要用到多线程且安全的队列怎么办呢？

ConcurrentLinkedQueue

线程安全、可高效读写的队列，高并发下性能最好的队列。
无锁、CAS比较交换算法，修改的方法包含三个核心参数(V,E,N)
V:要更新的变量、E:预期值、N:新值。
只有当V==E时, V=N;否则表示已被更新过,则取消当前操作。

import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

public class TestConcurrentLinkedQueue {
	public static void main(String[] args) {
		Queue<String> queue = new ConcurrentLinkedQueue<String>();
		queue.offer("Hello");//插入
		queue.offer("World");//插入
		queue.poll();//删除除He1lo
		queue.peek();//获得World
	}
}

ConcurrentLinkedQueue示例代码

import java.util.concurrent.ConcurrentLinkedQueue;
/**
 * ConcurrentLinkedQueue （非阻塞队列、无界队列）
 * 线程安全、可高效读写的队列，高并发下性能最好的队列。
 * 无锁、CAS比较交换算法，修改的方法包含三个核心参数（V,E,N）。
 * V：要更新的变量、E：预期值、N：新值。
 * 只有当V==E时，V=N；否则表示已被更新过，则取消当前操作。
 */
public class Demo8 {
	public static void main(String[] args) throws Exception {
		//1创建线程安全队列
		ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();
		//2入队操作
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				for(int i=1;i<=5;i++) {
					queue.offer(i);
				}
			}
		});
		Thread t2=new Thread(new Runnable() {
			@Override
			public void run() {
				for(int i=6;i<=10;i++) {
					queue.offer(i);
				}
			}
		});
		//3启动线程
		t1.start();
		t2.start();
		
		t1.join();
		t2.join();
		System.out.println("-------------出队-------------");
		//4出队操作
		int size=queue.size();
		for(int i=0;i<size;i++) {
			System.out.println(queue.poll());
		}
	}
}

8 BlockingQueue（阻塞队列`有界队列）

Queue的子接口，阻塞的队列，增加了两个线程状态为无限期等待的法。

方法:

void put(E e) //将指定元素插入此队列中，如果没有可用空间，则等待。
E take() //获取并移除此队列头部元素,如果没有可用元素，则等待。

可用于解决生产生、消费者问题。

ArrayBlockingQueue数组结构实现，有界队列。(手工固定. 上限)

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class TestArrayBlockingQueue {
	public static void main(String[ ] args) {
		BlockingQueue<String> abq = new ArrayBlockingQueue<String>(10);
	}
}

LinkedBlockingQueue链表结构实现，无界队列。(默认. 上限Integer.MAX_ VALUE)

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class TestLinkedBlockingQueue {
	public static void main(String[] args) {
		BlockingQueue<String> lbq = new LinkedBlockingQueue<String>();
	}
}

ArrayBlockingQueue示例代码

import java.util.concurrent.ArrayBlockingQueue;
/**
 * ArrayBlockingQueue 阻塞队列
 * put()
 * take()
 * size()
 * 当添加的数据超过数组的长度的时候，这时处于阻塞状态，等待删除数组中的元素，腾出空间
 */
public class Demo9 {
	public static void main(String[] args) throws Exception{
		//创建一个有界队列，添加数据
		ArrayBlockingQueue<String> queue=new ArrayBlockingQueue<>(5);
		//添加元素  不用add()方法
		queue.put("aaa");
		queue.put("bbb");
		queue.put("ccc");
		queue.put("ddd");
		queue.put("eee");
		//删除元素
		queue.take();
		System.out.println("已经添加了"+queue.size()+"个元素");
		queue.put("xyz");
		//System.out.println(queue.size());
		System.out.println("已经添加了6个元素");//超出集合大小，则阻塞
		System.out.println(queue.toString());
	}
}

LinkedBlockingQueue示例代码

import java.util.concurrent.LinkedBlockingQueue;
/**
 * LinkedBlockingQueue
 *	+ 链表结构实现，无界队列。
 *	+ 默认上限Integer.MAX_VALUE。
 *	+ 使用方法和ArrayBlockingQueue相同。
 * 功能：使用阻塞队列实现生产者和消费者。
 *注意：该案例能保证线程安全，但不保证生产者和消费者顺序交替执行，需要用到线程之间的通讯。
 */
public class Demo10 {
	public static void main(String[] args) {
		//1创建队列
		LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>(6);
		//2创建两个线程
		Thread t1=new Thread(new Runnable() {
			@Override
			public void run() {
				for(int i=0;i<30;i++) {
					try {
						queue.put(i);
					    //打印没有同步，可能发生生产和消费不一致的情况
		System.out.println(Thread.currentThread().getName()+"生产了第"+i+"号面包");
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}, "生产者");
		
		Thread t2=new Thread(new Runnable() {
			@Override
			public void run() {
				for(int i=0;i<30;i++) {
					try {
						Integer num=queue.take();
						//打印没有同步，可能发生生产和消费不一致的情况
		System.out.println(Thread.currentThread().getName()+"消费了第"+i+"号面包");
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}, "消费者");
		//启动线程
		t1.start();
		t2.start();
	}
}

总结

ExecutorService线程池接口、Executors工厂。
Callable线程任务、Future异步返回值。
Lock、ReentrantLock重入锁、 ReentrantReadWriteLock读写锁。
CopyOnWriteArrayList线程安全的ArrayList。
CopyOnWriteArraySet线程安全的Set。
ConcurrentHashMap线程安全的HashMap.
ConcurrentLinkedQueue线程安全的Queue。
ArrayBlockingQueue线程安全的阻塞Queue。(生产者、消费者)