有时为了控制同步, 我们一般会是用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。（在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤醒）
207
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
