有时为了控制同步, 我们一般会是用synchronized关键字或者对于变量使用volatile 进行修饰, 来达到并发的一个控制
synchronized
可以锁类,
对象实例,
其他对象,
wait和notify要放在synchronized里面,
join是等待其他线程执行后在一起执行,
yeild放弃争抢cpu执行
start是开启一个线程,会去调用runable接口的run方法,或者重写thread重写的run方法,也就是一个实现一个继承
- wait、notify方法
1.因为涉及到对象锁,他们必须都放在synchronized中来使用. Wait、Notify一定要在synchronized里面进行使用。
2.Wait必须暂定当前正在执行的线程,并释放资源锁,让其他线程可以有机会运行
3. notify/notifyall: 唤醒因锁池中的线程,使之运行
注意:一定要在线程同步中使用,并且是同一个锁的资源
- wait与sleep区别
对于sleep()方法,我们首先要知道该方法是属于Thread类中的。而wait()方法,则是属于Object类中的。
sleep()方法导致了程序暂停执行指定的时间,让出cpu该其他线程,但是他的监控状态依然保持者,当指定的时间到了又会自动恢复运行状态。
在调用sleep()方法的过程中,线程不会释放对象锁。
而当调用wait()方法的时候,线程会放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象调用notify()方法后本线程才进入对象锁定池准备
获取对象锁进入运行状态。
- Lock与synchronized 关键字的区别
Lock 接口可以尝试非阻塞地获取锁 当前线程尝试获取锁。如果这一时刻锁没有被其他线程获取到,则成功获取并持有锁。
Lock 接口能被中断地获取锁 与 synchronized 不同,获取到锁的线程能够响应中断,当获取到的锁的线程被中断时,中断异常将会被抛出,同时锁会被释放。
Lock 接口在指定的截止时间之前获取锁,如果截止时间到了依旧无法获取锁,则返回。
ReentrantLock 类
- 可重入
单线程可以重复进入,但要重复退出
- 可中断
lockInterruptibly()
- 可限时
超时不能获得锁,就返回false,不会永久等待构成死锁
- 公平锁
先来先得 public ReentrantLock(boolean fair)
public static ReentrantLock fairLock = new ReentrantLock(true);
案例:
- 可重入
package com.learn.first.jdkThread;
import java.util.concurrent.locks.ReentrantLock;
/**
* 手动说可重入(ReentrantLock)
* 1. 重入锁, 锁几次需要实施方案几次
* 2. 可中断锁,
*/
public class ReentrankLockThread implements Runnable {
/**手动锁*/
public static ReentrantLock lock = new ReentrantLock();
public static int i = 0;
public void run() {
for (int j = 0; j < 100000; j++) {
lock.lock(); // 加锁 , 锁加几次, 则需要释放几次
//lock.lock();
try {
i++; // 保证多线程下的安全操作
} finally {
lock.unlock(); // 释放锁
}
}
}
public static void main(String[] args) {
ReentrankLockThread reen = new ReentrankLockThread();
Thread t1 = new Thread(reen);
Thread t2 = new Thread(reen);
t1.start();t2.start();
try {
t1.join(); // 主线程等待t1执行完
t2.join(); // 主线程等待t2执行完
} catch (InterruptedException e) {
e.printStackTrace();
}
// 加锁后, 值200000
System.out.println(reen.i);
}
}
- 可中断
package com.learn.first.jdkThread;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrankLockInterruptor implements Runnable {
private static ReentrantLock lock1 = new ReentrantLock();
private static ReentrantLock lock2 = new ReentrantLock();
private int lock;
/**
* 控制加锁顺序, 构造死锁
* @param lock
*/
public ReentrankLockInterruptor(int lock) {
this.lock = lock;
}
public void run() {
try {
if (lock == 1) {
lock1.lockInterruptibly(); // 加入可中断锁
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
lock2.lockInterruptibly();
} else {
lock2.lockInterruptibly();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
lock1.lockInterruptibly();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (lock1.isHeldByCurrentThread()) {
lock1.unlock(); // 释放锁
}
if (lock2.isHeldByCurrentThread()) {
lock2.unlock();// 释放锁
}
System.out.println(Thread.currentThread().getId() + ":线程退出");
}
}
public static void main(String[] args) {
ReentrankLockInterruptor t1 = new ReentrankLockInterruptor(1);
ReentrankLockInterruptor t2 = new ReentrankLockInterruptor(2);
Thread th1 = new Thread(t1);
Thread th2 = new Thread(t2);
th1.start();th2.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// s死锁检查
DeadlockChecker.check();
}
}
package com.learn.first.jdkThread;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
/**
* 检查处于死锁状态的线程,并中断掉
*/
public class DeadlockChecker {
// Java 虚拟机线程系统的管理接口
private final static ThreadMXBean mbean = ManagementFactory.getThreadMXBean();
final static Runnable deadLockCheck = new Runnable() {
public void run() {
while (true) {
long[] deadlockedThreads = mbean.findDeadlockedThreads();
if (deadlockedThreads != null) {
ThreadInfo[] threadInfo = mbean.getThreadInfo(deadlockedThreads);
for (Thread t : Thread.getAllStackTraces().keySet()) {
for (int i = 0; i < threadInfo.length; i++) {
if (t.getId() == threadInfo[i].getThreadId()) {
t.interrupt();
}
}
}
}
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
public static void check() {
Thread t = new Thread(deadLockCheck);
t.setDaemon(true);
t.start();
}
}
- 超时
package com.learn.first.jdkThread;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
/**
* 锁超时后释放
*/
public class ReenTranckTimeLock implements Runnable {
private static ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
try {
// 锁 5秒,后释放
if (lock.tryLock(5, TimeUnit.SECONDS)) {
Thread.sleep(5000);
} else {
System.out.println("get lock failed");
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
if (lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}
public static void main(String[] args) {
ReenTranckTimeLock t1 = new ReenTranckTimeLock();
Thread th1 = new Thread(t1);
Thread thread = new Thread(t1);
th1.start();
thread.start();
}
}
Condition
- 概述
类似于 Object.wait()和Object.notify() 与ReentrantLock结合使用
- 主要接口
void await() throws InterruptedException;
void awaitUninterruptibly();
long awaitNanos(long nanosTimeout) throws InterruptedException;
boolean await(long time, TimeUnit unit) throws InterruptedException;
boolean awaitUntil(Date deadline) throws InterruptedException;
void signal(); void signalAll()#
- API详解
await()方法会使当前线程等待,同时释放当前锁,当其他线程中使用signal()时或者signalAll()方法时,线 程会重新获得锁并继续执行。或者当线程被中断时,也能跳出等待。这和Object.wait()方法很相似。
awaitUninterruptibly()方法与await()方法基本相同,但是它并不会再等待过程中响应中断。 singal()方法用于唤醒一个在等待中的线程。相对的singalAll()方法会唤醒所有在等待中的线程。这和Obej ct.notify()方法很类似。
Semaphore (信号量)
- 概述
Semaphore是一种基于计数的信号量。它可以设定一个阈值,基于此,多个线程竞争获取许可信号,做自己的申请后归还,超过阈值后,线程申请许可信号将会被阻塞。Semaphore可以用来构建一些对象池,资源池之类的,比如数据库连接池,我们也可以创建计数为1的Semaphore,将其作为一种类似互斥锁的机制,这也叫二元信号量,表示两种互斥状态。它的用法如下:
availablePermits函数用来获取当前可用的资源数量
wc.acquire(); //申请资源
wc.release();// 释放资源
共享锁
运行多个线程同时临界区
- 主要接口
public void acquire()
public void acquireUninterruptibly()
public boolean tryAcquire()
public boolean tryAcquire(long timeout, TimeUnit unit)
public void release()
- 案例
package com.learn.first.jdkThread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
* 信号量 :
* 允许运行多个线程同时共享
*/
public class SemapphoreDemo implements Runnable {
final Semaphore sema = new Semaphore(5);
@Override
public void run() {
try {
sema.acquire(); // 获取一个信号量
// 模拟操作
Thread.sleep(2000);
System.out.println(Thread.currentThread().getId()+":done");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
sema.release();// 释放信号量
}
}
public static void main(String[] args) {
ExecutorService execu = Executors.newFixedThreadPool(6);
final SemapphoreDemo demo = new SemapphoreDemo();
for (int i = 0; i < 20; i++) {
execu.submit(demo);
}
execu.shutdown();
}
}
ReadWriteLock (读写锁)
- 概述
ReadWriteLock是JDK5中提供的读写分离锁
- 访问情况
读-读不互斥:读读之间不阻塞。 读-写互斥:读阻塞写,写也会阻塞读。 写-写互斥:写写阻塞。
- 主要接口
private static ReentrantReadWriteLock readWriteLock=new ReentrantReadWriteLock();
private static Lock readLock = readWriteLock.readLock();
private static Lock writeLock = readWriteLock.writeLock();
CountDownLatch (倒数计时器)
- 概述
CountDownLatch 类位于java.util.concurrent包下,利用它可以实现类似计数器的功能。比如有一个任务A,它要等待其他4个任务执行完毕之后才能执行,此时就可以利用CountDownLatch来实现这种功能了。CountDownLatch是通过一个计数器来实现的,计数器的初始值为线程的数量。每当一个线程完成了自己的任务后,计数器的值就会减1。当计数器值到达0时,它表示所有的线程已经完成了任务,然后在闭锁上等待的线程就可以恢复执行任务。
倒数计时器
一种典型的场景就是火箭发射。在火箭发射前,为了保证万无一失,往往还要进行各项设备、仪器的检查。 只有等所有检查完毕后,引擎才能点火。这种场景就非常适合使用CountDownLatch。它可以使得点火线程
,等待所有检查线程全部完工后,再执行
- 主要接口
static final CountDownLatch end = new CountDownLatch(10);
end.countDown();
end.await();
- 案例
package com.learn.first.jdkThread;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CountDownLatchDemo implements Runnable {
static final CountDownLatch end = new CountDownLatch(10); // 倒计时砸栏
static final CountDownLatchDemo demo = new CountDownLatchDemo();
@Override
public void run() {
try {
// 模拟任务执行
Thread.sleep(1000);
System.out.println("1");
// 执行完任务, 计数器-1
end.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10; i++) {
executorService.submit(demo);
}
// 等待线程执行
end.await();
// 线程任务执行完毕
System.out.println("执行完毕.....");
executorService.shutdown();
}
}
CyclicBarrier (可循环使用的一个砸栏)
CyclicBarrier初始化时规定一个数目,然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时,所有进入等待状态的线程被唤醒并继续。
CyclicBarrier就象它名字的意思一样,可看成是个障碍, 所有的线程必须到齐后才能一起通过这个障碍。
CyclicBarrier初始时还可带一个Runnable的参数, 此Runnable任务在CyclicBarrier的数目达到后,所有其它线程被唤醒前被执行。
比如: 一个队伍有5个人(5个线程), 现在要执行2个操作, 1一个是集合, 一个是执行任务;
集合: 1. 等待5个线程都准备好了, 说明集合了, 2. 然后去做执行任务(5个任务),任务都完成了, 说明整个完成了
把5个人共通要做一件事, 作为一个拦截, 做完后, 继续做其他事情
- 概述
循环栅栏 Cyclic意为循环,也就是说这个计数器可以反复使用。比如,假设我们将计数器设置为10。那么凑齐第一批1 0个线程后,计数器就会归零,然后接着凑齐下一批10个线程
- 主要接口
public CyclicBarrier(int parties, Runnable barrierAction)
barrierAction就是当计数器一次计数完成后,系统会执行的动作
await()
- 例子
class Writer extends Thread {
private CyclicBarrier cyclicBarrier;
public Writer(CyclicBarrier cyclicBarrier){
this.cyclicBarrier=cyclicBarrier;
}
@Override
public void run() {
System.out.println("线程" + Thread.currentThread().getName() + ",正在写入数据");
try {
Thread.sleep(3000);
} catch (Exception e) {
// TODO: handle exception
}
System.out.println("线程" + Thread.currentThread().getName() + ",写入数据成功.....");
try {
cyclicBarrier.await();
} catch (Exception e) {
}
System.out.println("所有线程执行完毕..........");
}
}
public class Test001 {
public static void main(String[] args) {
CyclicBarrier cyclicBarrier=new CyclicBarrier(5);
for (int i = 0; i < 5; i++) {
Writer writer = new Writer(cyclicBarrier);
writer.start();
}
}
}
LockSupport
- 概述
提供线程阻塞原语
- 主要接口
LockSupport.park(); LockSupport.unpark(t1);
- 与suspend()比较
不容易引起线程冻结
- 中断响应
能够响应中断,但不抛出异常。 中断响应的结果是,park()函数的返回,可以从Thread.interrupted()得到中断标志
ReentrantLock 的实现
源码中可知:
- CAS状态
- 等待队列
- park()
并发容器 使用
Collections
Collections.synchronizedMap
public static Map m=Collections.synchronizedMap(new HashMap());synchronizedList
synchronizedSet
ConcurrentHashMap
高性能: 安全
阻塞队列与非阻塞队
阻塞队列与普通队列的区别在于,当队列是空的时,从队列中获取元素的操作将会被阻塞,或者当队列是满时,往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞,直到其他的线程往空的队列插入新的元素。同样,试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞,直到其他的线程使队列重新变得空闲起来,如从队列中移除一个或者多个元素,或者完全清空队列.
1.ArrayDeque, (数组双端队列)
2.PriorityQueue, (优先级队列)
3.ConcurrentLinkedQueue, (基于链表的并发队列)
4.DelayQueue, (延期阻塞队列)(阻塞队列实现了BlockingQueue接口)
5.ArrayBlockingQueue, (基于数组的并发阻塞队列)
6.LinkedBlockingQueue, (基于链表的FIFO阻塞队列)
7.LinkedBlockingDeque, (基于链表的FIFO双端阻塞队列)
8.PriorityBlockingQueue, (带优先级的无界阻塞队列)
9.SynchronousQueue (并发同步阻塞队列)
BlockingQueue 接口 (队列)
多线程中共享数据容器
ReentrantLock 与 Condition
读取: 没有数据,等待写入,否则读取
写入: 有数据,等待被读取,否则写入
BlockingQueue接口为代表的阻塞队列
ConcurrentLinkedQueue (高性能的队列)
ConcurrentLinkedQueue : 是一个适用于高并发场景下的队列,通过无锁的方式,实现
了高并发状态下的高性能,通常ConcurrentLinkedQueue性能好于BlockingQueue.它
是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。头是最先
加入的,尾是最近加入的,该队列不允许null元素。
ConcurrentLinkedQueue重要方法:
add 和offer() 都是加入元素的方法(在ConcurrentLinkedQueue中这俩个方法没有任何区别)
poll() 和peek() 都是取头元素节点,区别在于前者会删除元素,后者不会。
BlockingQueue
阻塞队列(BlockingQueue)是一个支持两个附加操作的队列。这两个附加的操作是:
在队列为空时,获取元素的线程会等待队列变为非空。
当队列满时,存储元素的线程会等待队列可用。
阻塞队列常用于生产者和消费者的场景,生产者是往队列里添加元素的线程,消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器,而消费者也只从容器里拿元素。
BlockingQueue即阻塞队列,从阻塞这个词可以看出,在某些情况下对阻塞队列的访问可能会造成阻塞。被阻塞的情况主要有如下两种:
- 当队列满了的时候进行入队列操作
- 当队列空了的时候进行出队列操作
因此,当一个线程试图对一个已经满了的队列进行入队列操作时,它将会被阻塞,除非有另一个线程做了出队列操作;同样,当一个线程试图对一个空队列进行出队列操作时,它将会被阻塞,除非有另一个线程进行了入队列操作。
在Java中,BlockingQueue的接口位于java.util.concurrent 包中(在Java5版本开始提供),由上面介绍的阻塞队列的特性可知,阻塞队列是线程安全的。
在新增的Concurrent包中,BlockingQueue很好的解决了多线程中,如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类,为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员,包括他们各自的功能以及常见使用场景。
认识BlockingQueue
阻塞队列,顾名思义,首先它是一个队列,而一个队列在数据结构中所起的作用大致如下图所示:
从上图我们可以很清楚看到,通过一个共享的队列,可以使得数据由队列的一端输入,从另外一端输出;
常用的队列主要有以下两种:(当然通过不同的实现方式,还可以延伸出很多不同类型的队列,DelayQueue就是其中的一种)
先进先出(FIFO):先插入的队列的元素也最先出队列,类似于排队的功能。从某种程度上来说这种队列也体现了一种公平性。
后进先出(LIFO):后插入队列的元素最先出队列,这种队列优先处理最近发生的事件。
多线程环境中,通过队列可以很容易实现数据共享,比如经典的“生产者”和“消费者”模型中,通过队列可以很便利地实现两者之间的数据共享。假设我们有若干生产者线程,另外又有若干个消费者线程。如果生产者线程需要把准备好的数据共享给消费者线程,利用队列的方式来传递数据,就可以很方便地解决他们之间的数据共享问题。但如果生产者和消费者在某个时间段内,万一发生数据处理速度不匹配的情况呢?理想情况下,如果生产者产出数据的速度大于消费者消费的速度,并且当生产出来的数据累积到一定程度的时候,那么生产者必须暂停等待一下(阻塞生产者线程),以便等待消费者线程把累积的数据处理完毕,反之亦然。然而,在concurrent包发布以前,在多线程环境下,我们每个程序员都必须去自己控制这些细节,尤其还要兼顾效率和线程安全,而这会给我们的程序带来不小的复杂度。好在此时,强大的concurrent包横空出世了,而他也给我们带来了强大的BlockingQueue。(在多线程领域:所谓阻塞,在某些情况下会挂起线程(即阻塞),一旦条件满足,被挂起的线程又会自动被唤醒)