1、什么是JUC
1.1JUC简介
JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包，JDK 1.5开始出现的。
1.2进程与线程
进程（Process） 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。程序是指令、数据及其组织形式的描述，进程是程序的实体。
线程（thread） 是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
1.3线程的状态
1.3.1线程状态枚举类
public enum State {
/**
* Thread state for a thread which has not yet started.
*/
NEW,
/**
* Thread state for a runnable thread. A thread in the runnable
* state is executing in the Java virtual machine but it may
* be waiting for other resources from the operating system
* such as processor.
*/
RUNNABLE,
/**
* Thread state for a thread blocked waiting for a monitor lock.
* A thread in the blocked state is waiting for a monitor lock
* to enter a synchronized block/method or
* reenter a synchronized block/method after calling
* {@link Object#wait() Object.wait}.
*/
BLOCKED,
/**
* Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
* <ul>
* <li>{@link Object#wait() Object.wait} with no timeout</li>
* <li>{@link #join() Thread.join} with no timeout</li>
* <li>{@link LockSupport#park() LockSupport.park}</li>
* </ul>
*
* <p>A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called <tt>Object.wait()</tt>
* on an object is waiting for another thread to call
* <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
* that object. A thread that has called <tt>Thread.join()</tt>
* is waiting for a specified thread to terminate.
*/
WAITING,
/**
* Thread state for a waiting thread with a specified waiting time.
* A thread is in the timed waiting state due to calling one of
* the following methods with a specified positive waiting time:
* <ul>
* <li>{@link #sleep Thread.sleep}</li>
* <li>{@link Object#wait(long) Object.wait} with timeout</li>
* <li>{@link #join(long) Thread.join} with timeout</li>
* <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
* <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
* </ul>
*/
TIMED_WAITING,
/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
TERMINATED;
}
1.3.2wait/sleep的区别
（1）sleep是Thread的静态方法，wait是Object的方法，任何对象实例都能调用。
（2）sleep不会释放锁，它也不需要占用锁。wait会释放锁，但调用它的前提是当前线程占有锁(即代码要在synchronized中)。
（3）它们都可以被interrupted方法中断。
1.4并发与并行
并发：同一时刻多个线程在访问同一个资源，多个线程对一个点
例子：春运抢票 电商秒杀…
并行：多项工作一起执行，之后再汇总
例子：泡方便面，电水壶烧水，一边撕调料倒入桶中
1.5管程
管程(monitor)是保证了同一时刻只有一个进程在管程内活动,即管程内定义的操作在同一时刻只被一个进程调用(由编译器实现).但是这样并不能保证进程以设计的顺序执行
JVM中同步是基于进入和退出管程(monitor)对象实现的，每个对象都会有一个管程(monitor)对象，管程(monitor)会随着java对象一同创建和销毁
执行线程首先要持有管程对象，然后才能执行方法，当方法完成之后会释放管程，方法在执行时候会持有管程，其他线程无法再获取同一个管程
1.6用户线程和守护线程
用户线程:平时用到的普通线程,自定义线程
守护线程:运行在后台,是一种特殊的线程,比如垃圾回收
当主线程结束后,用户线程还在运行,JVM存活
如果没有用户线程,都是守护线程,JVM结束
2、lock接口
2.1synchronized关键字回顾
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：
1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。
如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：
1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；
2）线程执行发生异常，此时JVM会让线程自动释放锁。
那么如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，试想一下，这多么影响程序执行效率。
因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。
2.2什么是lock
Lock与的Synchronized区别
• Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；
• Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。
2.2.1lock接口
public interface Lock {
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock();
Condition newCondition();
}
2.2.2lock()
lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。
采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用Lock来进行同步的话，是以下面这种形式去使用的：
Lock lock = ...;
lock.lock();
try{
//处理任务
} catch(Exception ex){
} finally{
lock.unlock(); //释放锁
}
2.2.3 newCondition
关键字synchronized与wait()/notify()这两个方法一起使用可以实现等待/通知模式， Lock锁的newContition()方法返回Condition对象，Condition类也可以实现等待/通知模式。
用notify()通知时，JVM会随机唤醒某个等待的线程， 使用Condition类可以进行选择性通知， Condition比较常用的两个方法：
• await()会使当前线程等待,同时会释放锁,当其他线程调用signal()时,线程会重新获得锁并继续执行。
• signal()用于唤醒一个等待的线程。
注意：在调用Condition的await()/signal()方法前，也需要线程持有相关的Lock锁，调用await()后线程会释放这个锁，在singal()调用后会从当前Condition对象的等待队列中，唤醒 一个线程，唤醒的线程尝试获得锁， 一旦获得锁成功就继续执行。
2.3 ReentrantLock
ReentrantLock，意思是“可重入锁”，关于可重入锁的概念将在后面讲述。
ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法。
2.4 ReadWriteLock
ReadWriteLock也是一个接口，在它里面只定义了两个方法：
public interface ReadWriteLock {
/**
* Returns the lock used for reading.
*
* @return the lock used for reading
*/
Lock readLock();
/**
* Returns the lock used for writing.
*
* @return the lock used for writing
*/
Lock writeLock();
}
一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作。下面的ReentrantReadWriteLock实现了ReadWriteLock接口。
ReentrantReadWriteLock里面提供了很多丰富的方法，不过最主要的有两个方法：readLock()和writeLock()用来获取读锁和写锁。
注意：
- 如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。
- 如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。
2.5Lock和synchronized的区别
- Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
- synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
- Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
- 通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
- Lock可以提高多个线程进行读操作的效率。
在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。
2.6synchronized实现案例
public class Ticket {
private Integer count = 30;
public synchronized void sale(){
if (count > 0){
System.out.println(Thread.currentThread().getName() + "卖出第" + (count--) + "张票");
}
}
}
测试:
public static void main(String[] args) {
Ticket ticket = new Ticket();
new Thread(() -> {
for (int i = 0; i < 30; i++) {
ticket.sale();
}
},"AA").start();
new Thread(() -> {
for (int i = 0; i < 30; i++) {
ticket.sale();
}
},"BB").start();
new Thread(() -> {
for (int i = 0; i < 30; i++) {
ticket.sale();
}
},"CC").start();
}
2.7lock实现案例
public class LTicket {
private Integer count = 30;
private ReentrantLock lock = new ReentrantLock();
public void sale(){
lock.lock();
try {
if (count > 0){
System.out.println(Thread.currentThread().getName() + "卖出第" + (count--) + "张票");
}
} catch (Exception e){
} finally {
lock.unlock();
}
}
}
测试:
public static void main(String[] args) {
LTicket ticket = new LTicket();
new Thread(()->{
for (int i = 0; i < 30; i++) {
ticket.sale();
}
}, "AA").start();
new Thread(()->{
for (int i = 0; i < 30; i++) {
ticket.sale();
}
}, "BB").start();
new Thread(()->{
for (int i = 0; i < 30; i++) {
ticket.sale();
}
}, "CC").start();
}
3、线程间通信
线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析:
场景—两个线程，一个线程对当前数值加1，另一个线程对当前数值减1,要求用线程间通信
3.1synchronized方案
资源类:
public class DemoEntity {
private int number = 0;
public synchronized void incr() {
try {
while (number > 0){
this.wait();
}
number++;
System.out.println(Thread.currentThread().getName() + "::" + number);
notifyAll();
} catch (Exception e){
e.printStackTrace();
}
}
public synchronized void decr() {
try {
while (number <= 0){
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName() + "::" + number);
notifyAll();
} catch (Exception e){
e.printStackTrace();
}
}
}
多线程调用:
public static void main(String[] args) {
DemoEntity demoEntity = new DemoEntity();
new Thread(()->{
for (int i = 0; i < 10; i++) {
demoEntity.incr();
}
}, "AA").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
demoEntity.decr();
}
}, "BB").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
demoEntity.incr();
}
}, "CC").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
demoEntity.decr();
}
}, "DD").start();
}
3.2lock方案
资源类:
public class LDemoEntity {
private int number = 0;
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public void incr() {
lock.lock();
try {
while (number > 0){
condition.await();
}
number++;
System.out.println(Thread.currentThread().getName() + "::" + number);
condition.signalAll();
} catch (Exception e){
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void decr() {
lock.lock();
try {
while (number <= 0){
condition.await();
}
number--;
System.out.println(Thread.currentThread().getName() + "::" + number);
condition.signalAll();
} catch (Exception e){
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
多线程调用:
public static void main(String[] args) {
LDemoEntity demoEntity = new LDemoEntity();
new Thread(()->{
for (int i = 0; i < 10; i++) {
demoEntity.incr();
}
}, "AA").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
demoEntity.decr();
}
}, "BB").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
demoEntity.incr();
}
}, "CC").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
demoEntity.decr();
}
}, "DD").start();
}
3.3线程间定制化通信
资源类:
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author lyz
* @Title: CustomDemoEntity
* @Description:
* @date 2021/9/13 13:14
*/
public class CustomDemoEntity {
private int flag = 1;
private Lock lock = new ReentrantLock();
private Condition c1 = lock.newCondition();
private Condition c2 = lock.newCondition();
private Condition c3 = lock.newCondition();
public void printA(int loop){
lock.lock();
try {
while (flag != 1){
c1.await();
}
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + "::第" + loop + "次循环::" + flag);
}
flag = 2;
c2.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printB(int loop){
lock.lock();
try {
while (flag != 2){
c2.await();
}
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "::第" + loop + "次循环::" + flag);
}
flag = 3;
c3.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printC(int loop){
lock.lock();
try {
while (flag != 3){
c3.await();
}
for (int i = 0; i < 15; i++) {
System.out.println(Thread.currentThread().getName() + "::第" + loop + "次循环::" + flag);
}
flag = 1;
c1.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
多线程调用:
public static void main(String[] args) {
CustomDemoEntity demoEntity = new CustomDemoEntity();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
demoEntity.printA(i);
}
}, "AA").start();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
demoEntity.printB(i);
}
}, "BB").start();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
demoEntity.printC(i);
}
}, "CC").start();
}
3.4多线程编程步骤
1.创建资源类，在资源类创建属性和操作方法
- 判断
- 干活
- 通知
2.创建多个线程,调用资源类的操作方法
3.防止虚假唤醒问题
4、集合的线程安全
4.1ArrayList线程安全问题
测试代码:
public static void main(String[] args) {
// List<String> list = new ArrayList<>();
// List<String> list = new Vector<>();
// List<String> list = Collections.synchronizedList(new ArrayList<>());
List<String> list = new CopyOnWriteArrayList<>();
for (int i = 0; i < 20; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString());
System.out.println(list);
}, "aa").start();
}
}
ArrayList的add方法并发读写时发生java.util.ConcurrentModificationException异常，它并不是一个线程安全的集合。
使用Vector或Collections.synchronizedList来保证list并发执行时的线程安全(底层使用synchronized)。
4.2CopyOnWriteArrayList
它相当于线程安全的ArrayList。和ArrayList一样，它是个可变数组；但是和ArrayList不同的时，它具有以下特性：
- 它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多于可变操作，需要在遍历期间防止线程间的冲突。
- 它是线程安全的。
- 因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove() 等等）的开销很大。
- 迭代器支持hasNext(), next()等不可变操作，但不支持可变 remove()等操作。
- 使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照。
当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行 Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。
public class CopyOnWriteArrayList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
private static final long serialVersionUID = 8673264195747942595L;
/** The lock protecting all mutators */
final transient ReentrantLock lock = new ReentrantLock();
/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;
final Object[] getArray() {
return array;
}
final void setArray(Object[] a) {
array = a;
}
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
*/
public boolean add(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
4.3HashSet线程安全问题
测试代码:
public static void main(String[] args) {
// Set<String> list = new HashSet<>();
// Set<String> list = Collections.synchronizedSet(new HashSet<>());
Set<String> list = new CopyOnWriteArraySet<>();
for (int i = 0; i < 20; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString().substring(0,6));
System.out.println(list);
}, "aa").start();
}
}
使用Collections.synchronizedSet或CopyOnWriteArraySet解决Set集合线程安全问题。
4.4HashMap线程安全问题
测试代码:
public static void main(String[] args) {
// Map<String, String> list = new HashMap<>();
// Map<String, String> list = Collections.synchronizedMap(new HashMap<>());
Map<String, String> list = new ConcurrentHashMap<>();
for (int i = 0; i < 20; i++) {
String key = String.valueOf(i);
new Thread(() -> {
list.put(key, UUID.randomUUID().toString().substring(0,6));
System.out.println(list);
}, "aa").start();
}
}
使用Collections.synchronizedMap或ConcurrentHashMap解决Map集合线程安全问题。
4.5 小结
1.线程安全与线程不安全集合
集合类型中存在线程安全与线程不安全的两种,常见例如:
ArrayList ----- Vector
HashMap -----HashTable
但是以上都是通过synchronized关键字实现,效率较低
2.Collections构建的线程安全集合
3.java.util.concurrent并发包下
CopyOnWriteArrayList、CopyOnWriteArraySet、ConcurrentHashMap(推荐)