JUC并发编程入门
1.什么是JUC
java.util.concurrent(并发的)
2.线程与进程
进程：一个程序，例如CSDN.exe、QQ.exe等程序的集合；
一个进程往往可以包含多个线程，至少包含一个！
java默认有几个线程？ 2个 main、GC
线程：例如一个Typora进程，里面会包括写入、自动保存（都由线程负责）等线程
对于java而言：Thread、Runnable、Callable
Java真的可以开启线程吗？ 开不了
public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
// 本地方法，底层的c++，java无法直接操作硬件
private native void start0();
并发、并行
并发编程：并行、并发
并发：多线程交替获取CPU时间片，逻辑上认为同时执行多件事，实际上并非同一时刻（针对于单个CPU而言）
cpu一核，模拟出多条线程，天下武功，唯快不破，快速交替
并行：多个线程同时执行，真正意义上的同时执行（针对于多CPU而言）
并发编程的本质：充分利用cpu的资源
java中线程有几个状态
public enum State {
// 新生
NEW,
// 运行
RUNNABLE,
// 阻塞
BLOCKED,
// 等待
WAITING,
// 超时等待
TIMED_WAITING,
// 终止
TERMINATED;
wait、sleep的区别
1.来自不同的类
wait => Object
sleep => Thread
2.关于锁的释放
wait会释放锁，sleep睡觉了，抱着锁睡觉，不会释放！
wait： 释放锁
sleep： 不释放锁
3.使用的范围是不同的
wait： 必须在同步代码块儿
sleep： 在哪都能执行
4.是否需要捕获异常
wait： 不需要捕获异常
sleep： 必须要捕获异常
3.Lock锁（重点）
传统synchronized关键字
package com.coderzpw.demo;
// 基本买票例子
/**
* 正在的多线程开发，公司中的开发
*/
public class SaleTicketDemo01 {
public static void main(String[] args) {
// 并发： 多线程操作同一个资源类，把资源类丢进线程
final Ticket ticket = new Ticket();
// @FunctionalInterface 函数式接口，jdk1.8 lambda表达式 （参数）->{代码}
new Thread(()->{
for (int i=1; i<20; i++){
ticket.sale();
}
},"A").start();
new Thread(()->{
for (int i=1; i<20; i++){
ticket.sale();
}
},"B").start();new Thread(()->{
for (int i=1; i<20; i++){
ticket.sale();
}
},"C").start();
}
}
// synchronized
class Ticket{
private int number = 50;
// 买票的方式
public synchronized void sale(){
if (number>0){
System.out.println(Thread.currentThread().getName()+"卖出了"+(50-number)+"几张票，剩余"+number+"张票");
number--;
}
}
}
lock接口
实现类1：ReentrantLock(可重入锁)
实现类2：ReentrantReadWriteLock -> ReadLock(读-写锁)
实现类3：ReentrantReadWriteLock -> WriteLock(读-写锁)
package com.coderzpw.demo;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SaleTicketDemo02 {
public static void main(String[] args) {
// 并发： 多线程操作同一个资源类，把资源类丢进线程
final Ticket2 ticket2 = new Ticket2();
// @FunctionalInterface 函数式接口，jdk1.8 lambda表达式 （参数）->{代码}
new Thread(()->{
for (int i=1; i<20; i++){
ticket2.sale();
}
},"A").start();
new Thread(()->{
for (int i=1; i<20; i++){
ticket2.sale();
}
},"B").start();new Thread(()->{
for (int i=1; i<20; i++){
ticket2.sale();
}
},"C").start();
}
}
/**
* lock三部曲
* 1. new ReentrantLock()
* 2. lock.lock(); // 加锁
* 3. lock.unlock(); // 解锁
*/
class Ticket2{
private int number = 50;
Lock lock = new ReentrantLock();
// 买票的方式
public synchronized void sale(){
lock.lock(); // 加锁
try {
// 业务代码
if (number>0){
System.out.println(Thread.currentThread().getName()+"卖出了"+(50-number)+"几张票，剩余"+number+"张票");
number--;
}
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock(); // 解锁
}
}
}
公平锁： 排队，先来后到
非公平锁： 可以插队 （默认）
Synchronized 和 Lock的区别
- Synchronized 内置的java关键字； Lock 是一个java接口
- Synchronized 无法判断获取锁的状态； Lock可以判断是否获取到锁
- Synchronized 会自动释放锁； Lock必须手动释放锁，否则就会死锁
- Synchronized 线程1（获取锁，阻塞）、线程2（等待，傻傻的等）； Lock锁就不会一直等下去
- Synchronized 可重入锁，不可以中断的，非公平锁； Lock，可重入锁，可以判断锁状态，公平与否可以手动设置（默认非公平）
- Synchronized 适合锁少量的代码同步问题； Lock适合锁大量的同步代码块
锁是什么？如何判断锁的是谁？
4.生产者与消费者
面试的：单例模式、排序算法、生产者和消费者、死锁
生产者与消费者问题 Synchronized 版
package com.coderzpw.demo.pc;
/**
* 线程之间的通信问题： 生产者和消费者问题！ 等待唤醒、通知唤醒
* 线程交替执行 A B C D 操作同一个变量 coin =0
* A coin +1
* B coin -1
* C coin -1
* D coin +1
*/
public class A {
public static void main(String[] args) {
Data data = new Data();
new Thread(()->{
// 这个线程执行 +1
for (int i=0; i<5; i++){
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"A").start();
new Thread(()->{
// 这个线程执行 -1
for (int i=0; i<5; i++){
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"B").start();
new Thread(()->{
// 这个线程执行 -1
for (int i=0; i<5; i++){
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"C").start();
new Thread(()->{
// 这个线程执行 +1
for (int i=0; i<5; i++){
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"D").start();
}
}
class Data{
// 数字 资源类
private int coin = 0;
// +1
public synchronized void increment() throws InterruptedException {
while(coin!=0){
// 这里必须要有while ，如果用if的话，当其他地方使用notifyAll()方法后该线程会直接唤醒，
//当该线程抢到锁之后线程就不会再判断是否等待的条件了(所以要用while一直判断)，即coin是否=0 就直接调用后面的方法，这时就是不应该
//被唤醒的线程被唤醒了，就会造成线程不安全的现象（这种现象被称为虚假唤醒）
// 等待
this.wait();
}
coin++;
System.out.println(Thread.currentThread().getName()+"=>>"+coin);
// 通知其他线程，我+1完毕了
this.notifyAll();
}
// -1
public synchronized void decrement() throws InterruptedException {
while(coin==0){
// 等待
this.wait();
}
coin--;
System.out.println(Thread.currentThread().getName()+"=>>"+coin);
// 通知其他线程，我-1完毕了
this.notifyAll();
}
}
如果用if判断执行结果：
如果用while判断执行结果：
虚假唤醒：
当一个条件满足时，很多线程都被唤醒了，但是只有其中部分是有用的唤醒，其它的唤醒都是无用功
比如说买货，如果商品本来没有货物，突然进了一件商品，这是所有的线程都被唤醒了
，但是只能一个人买，所以其他人都是假唤醒，获取不到对象的锁
JUC版本的生产者和消费者问题
代码演示
package com.coderzpw.demo.pc;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class B {
public static void main(String[] args) {
Data1 data1 = new Data1();
new Thread(()->{
// 这个线程执行 +1
for (int i=0; i<5; i++){
try {
data1.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"A").start();
new Thread(()->{
// 这个线程执行 -1
for (int i=0; i<5; i++){
try {
data1.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"B").start();
new Thread(()->{
// 这个线程执行 -1
for (int i=0; i<5; i++){
try {
data1.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"C").start();
new Thread(()->{
// 这个线程执行 +1
for (int i=0; i<5; i++){
try {
data1.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"D").start();
}
}
class Data1{
// 数字 资源类
private int coin = 0;
// 建一个锁对象
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
// condition.await(); 等同于原来的wait方法 等待
// condition.signalAll(); 等同于原来的notifyAll方法 唤醒全部
// condition.signal(); 等同于原来的notify方法 唤醒某一个
// +1
public void increment() throws InterruptedException {
// 业务代码写在try里，解锁写在finally里保证无论怎样都能执行解锁，避免死锁
try {
lock.lock(); // 加锁
while (coin!=0){
// 等待
condition.await();
}
coin++;
System.out.println(Thread.currentThread().getName()+"=>>"+coin);
// 通知其他线程，我+1完毕了
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock(); // 解锁
}
}
// -1
public synchronized void decrement() throws InterruptedException {
try {
lock.lock();
while (coin==0){
// 等待
condition.await();
}
coin--;
System.out.println(Thread.currentThread().getName()+"=>>"+coin);
// 通知其他线程，我-1完毕了
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
精准唤醒 通过不同的condition对象进行精准唤醒
package com.coderzpw.demo.pc;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 要求 A执行完调用B，B执行完调用C，C执行完调用A
*/
public class C {
public static void main(String[] args) {
Data2 data2 = new Data2();
new Thread(()->{
for (int i=0; i<10; i++){
data2.printA();
}
},"A").start();
new Thread(()->{
for (int i=0; i<10; i++){
data2.printB();
}
},"B").start();
new Thread(()->{
for (int i=0; i<10; i++){
data2.printC();
}
},"C").start();
}
}
class Data2{
// 资源类 Lock
public Lock lock = new ReentrantLock(); // 锁对象
public Condition condition1 = lock.newCondition(); // 锁监视器1
public Condition condition2 = lock.newCondition(); // 锁监视器2
public Condition condition3 = lock.newCondition(); // 锁监视器3
private int num = 1; // 1A 2B 3C
public void printA(){
try {
lock.lock();
// 业务， 判断-> 执行 -> 通知
while(num!=1){
// 等待
condition1.await();
}
System.out.println(Thread.currentThread().getName()+"=>>AAAAAA");
// 唤醒，唤醒指定的人，B
num = 2;
condition2.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printB(){
try {
lock.lock();
// 业务， 判断-> 执行 -> 通知
while(num!=2){
// 等待
condition2.await();
}
System.out.println(Thread.currentThread().getName()+"=>>BBBBBB");
// 唤醒，唤醒指定的人，B
num = 3;
condition3.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printC(){
try {
lock.lock();
// 业务， 判断-> 执行 -> 通知
while(num!=3){
// 等待
condition3.await();
}
System.out.println(Thread.currentThread().getName()+"=>>CCCCCC");
// 唤醒，唤醒指定的人，B
num = 1;
condition1.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
5、8锁现象（锁的八个问题）
如何判断锁的是谁？ 对象、Class
package com.coderzpw.demo.lock8;
import java.util.concurrent.TimeUnit;
/**
* 8锁，就是关于锁的8个问题
* 1. 同一个phone，标准情况下，两个线程先打印“发短信”还是“打电话” 答：先发短信 后打电话
* 2. 同一个phone，sendSms延迟4秒，两个线程先打印什么？ 答：先发短信 后打电话 （因为锁的是同一个对象，且调用sleep方法并不会释放锁）
*/
public class Test1 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(4); // 先睡眠4秒
} catch (InterruptedException e) {
e.printStackTrace();
}
phone.sendSms();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1); // 线程休眠一秒 JUC版本的休眠 类似于Thread.sleep()
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.call();
},"B").start();
}
}
class Phone{
// synchronized 锁的对象是方法的调用者！
// 两个方法用的同一个锁，谁先拿到谁执行
public synchronized void sendSms(){
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
package com.coderzpw.demo.lock8;
import java.util.concurrent.TimeUnit;
/**
* 3、同一个phone，增加了一个普通方法后，先打印“发短信”还是“hello”？ 答：先hello后发短信
* （因为hello没有加synchronized，没有加锁，不是同步方法，不会受锁的影响。）
* 4、 不同phone，两个对象，两个同步方法，先发短信还是先打电话？ 答：先打电话，后发短信 （因为这是两个不同的对象，是不同的两把锁）
*/
public class Test2 {
public static void main(String[] args) {
// 两个对象
Phone2 Phone21 = new Phone2();
Phone2 phone22 = new Phone2();
new Thread(()->{
Phone21.sendSms(); },"A").start();
try {
TimeUnit.SECONDS.sleep(1); // 线程休眠一秒 JUC版本的休眠 类似于Thread.sleep()
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone22.call(); },"B").start();
}
}
class Phone2{
// synchronized 锁的对象是方法的调用者！
// 两个方法用的同一个锁，谁先拿到谁执行
public synchronized void sendSms(){
try {
// 调用sendSms的时候 要先睡眠4秒
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
public void hello(){
System.out.println("hello");
}
}
package com.coderzpw.demo.lock8;
import java.util.concurrent.TimeUnit;
/**
* 5、增加两个静态的同步方法，只有一个对象，先打印“发短信”还是“打电话”？ 答：先发短信后打电话
* 6、两个对象！增加两个静态的同步方法，只有一个对象，先打印“发短信”还是“打电话”？ 答：先发短信后打电话（因为锁的是一个类，一个已经占用了类，另一个就只能阻塞）
*/
public class Test3 {
public static void main(String[] args) {
// 两个对象的Class类模板只有一个，static，锁的是Class
Phone3 phone31 = new Phone3();
Phone3 phone32 = new Phone3();
new Thread(()->{
phone31.sendSms(); },"A").start();
try {
TimeUnit.SECONDS.sleep(1); // 线程休眠一秒 JUC版本的休眠 类似于Thread.sleep()
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone32.call(); },"B").start();
}
}
// Phone3唯一的一个class对象
class Phone3{
// synchronized 锁的对象是方法的调用者！
// static 静态方法
// 类一加载就有了！ 锁的是Class模板
public static synchronized void sendSms(){
try {
// 调用sendSms的时候 要先睡眠4秒
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public static synchronized void call(){
System.out.println("打电话");
}
public void hello(){
System.out.println("hello");
}
}
package com.coderzpw.demo.lock8;
import java.util.concurrent.TimeUnit;
/**
* 7、一个静态同步方法，一个普通同步方法，一个对象，先打印哪一个？ 答：先打电话，后发短信 （因为这两个方法锁的东西是不一样的，一个是类，一个是对象。所以互不影响）
* 8、一个静态同步方法，一个普通同步方法，两个对象，先打印哪一个？ 答：先打电话，后发短信 （原因同上）
*/
public class Test4 {
public static void main(String[] args) {
Phone4 phone41 = new Phone4();
Phone4 phone42 = new Phone4();
new Thread(()->{
phone41.sendSms(); },"A").start();
try {
TimeUnit.SECONDS.sleep(1); // 线程休眠一秒 JUC版本的休眠 类似于Thread.sleep()
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone42.call(); },"B").start();
}
}
// Phone4
class Phone4{
// static 静态同步方法 锁的是Class类模板
public static synchronized void sendSms(){
try {
// 调用sendSms的时候 要先睡眠4秒
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
// 普通同步方法、锁的是调用者
public synchronized void call(){
System.out.println("打电话");
}
}
6、集合类线程不安全（ArrayList、HashSet、HashMap都是线程不安全的）
这图上的集合类之间的关系 不包括java.util.concurrent里面的类
1. List
public class ListTest {
public static void main(String[] args) {
List<String > list = new ArrayList<>();
for (int i=0; i<20; i++){
new Thread(()->{
list.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(list);
},String.valueOf(i)).start();
}
}
}
package com.coderzpw.demo.unsafe;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* @author 小虎牙
*
* 1. 故障现象
* java.util.ConcurrentModificationException 并发修改异常
* 2. 导致原因
*
* 3. 解决方法
* (1) 使用List list = new Vector<>(); Vector是线程安全的(其源码内部的对集合的读写方法都加了synchronized关键字)
* (2) 使用List list = Collections.synchronizedList(new ArrayList<>()) Collections是集合工具类 Collection是集合的上层接口
* (3) 使用JUC下面的CopyOnWriteArrayList类（写时赋值集合） List list = new CopyOnWriteArrayList<>(); 内部源码只在写方面加了锁
* 4. 优化建议（同样的错误不犯两次）
*/
public class ListTest {
public static void main(String[] args) {
listNotSafe();
}
public static void listNotSafe(){
List<String> list = new CopyOnWriteArrayList<>(); //Collections.synchronizedList(new ArrayList<>());//new Vector<>(); //new ArrayList<>();
for (int i=0; i<20; i++){
new Thread(()->{
list.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(list);
},String.valueOf(i)).start();
}
}
}
CopyOnWriteArrayList类
2. set
package com.coderzpw.demo.unsafe;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;
public class SetTest {
public static void main(String[] args) {
setNotSafe();
}
public static void setNotSafe(){
Set<String> set = new CopyOnWriteArraySet<String>();
for (int i=0; i<20; i++){
new Thread(()->{
set.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(set);
},String.valueOf(i)).start();
}
}
}
3.map
package com.coderzpw.demo.unsafe;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
public class MapTest {
public static void main(String[] args) {
mapNotSafe();
}
public static void mapNotSafe(){
Map map = new ConcurrentHashMap();
for (int i=0; i<20; i++){
new Thread(()->{
map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,5));
System.out.println(map);
},String.valueOf(i)).start();
}
}
}