部分内容参考自JavaGuide 并发基础、JavaGuide 并发进阶
一 进程和线程
进程
进程是程序的一次动态执行过程，它经历了从代码加载、执行到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到最终消亡的过程
线程
线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多
main 线程执行 main 方法，一个 Java 程序的运行是 main 线程和多个其他线程同时运行
线程状态
从Java API层面来看，分为新建、可运行（就绪+运行+操作系统层面的阻塞）、等待、超时等待、Java层面的阻塞、终止六种状态
更正：原图中 wait 到 runnable 状态的转换中，join是Thread类的方法
进程与线程的关系
一个进程中可以有多个线程，多个线程共享进程的堆和方法区 (JDK1.8 之后的元空间)资源，但是每个线程有自己的程序计数器、虚拟机栈 和 本地方法栈。
程序计数器：线程切换后能恢复到正确的执行位置
虚拟机栈和本地方法栈：虚拟机栈为虚拟机执行 Java 方法 （也就是字节码）服务，而本地方法栈则为虚拟机使用到的 Native 方法服务，都是保证线程中的局部变量不被别的线程访问到
堆和方法区：堆是进程中最大的一块内存，主要用于存放新创建的对象 (几乎所有对象都在这里分配内存)，方法区主要用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据
进程与线程的区别
线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。线程执行开销小，但不利于资源的管理和保护；而进程正相反
同步与异步
- 同步：需要等待结果返回，才能继续运行
- 异步：不需要等待结果返回，就能继续运行
线程上下文切换
当出现如下情况的时候，线程会从占用 CPU 状态中退出。
- cpu时间片用完
- 垃圾回收
- 有更高优先级的线程需要运行
- 调用sleep,yield,wait,join,park,synchronized,lock方法
线程切换意味着需要保存当前线程的上下文（程序计数器、虚拟机栈的栈帧信息），留待线程下次占用 CPU 的时候恢复现场，频繁切换就会造成整体效率低下
二 多线程基础
创建线程
-
继承Thread类
public class MyThread extends Thread { private int ticket=5; @Override public void run() { for (int i = 0; i < 100; i++) { if(ticket>0) { System.out.println("卖票，ticket="+ticket--); } } } }public class Main { public static void main(String[] args) throws Exception { MyThread mt1=new MyThread(); mt1.start(); //也可以使用匿名内部类创建 Thread thread=new Thread() { @Override public void run() { System.out.println("run"); } }; thread.setName("thread1"); thread.start(); } } -
实现Runnable接口（解决了继承Thread之后不能继承其它类的问题）
public class MyThread implements Runnable { private int ticket=5; @Override public void run() { for (int i = 0; i < 100; i++) { if(ticket>0) { System.out.println("卖票，ticket="+ticket--); } } } }public class Main { public static void main(String[] args) throws Exception { MyThread mt1=new MyThread(); new Thread(mt1).start(); //也可以使用匿名内部类创建 Runnable runnable=new Runnable() { @Override public void run() { System.out.println("run"); } }; //还可以使用lambda表达式简化，因为Runnable是函数式接口 //Runnable runnable= () -> System.out.println("run"); Thread thread2=new Thread(runnable,"thread2"); thread2.start(); } } -
实现Callable接口（相比实现Runnable接口可以返回结果、抛出异常）
public class MyThread implements Callable<String> { private int ticket=5; @Override public String call() throws Exception { for (int i = 0; i < 100; i++) { if(ticket>0) { System.out.println("卖票，ticket="+ticket--); } } return "no ticket"; } }public class Main { public static void main(String[] args) throws Exception { MyThread mt1=new MyThread(); FutureTask<String> task=new FutureTask<String>(mt1); //也可以使用匿名内部类创建 FutureTask<String> task1=new FutureTask<String>(new Callable<String>() { @Override public String call() throws Exception { System.out.println("run"); return "finish"; } }); new Thread(task).start(); System.out.println("return "+task.get()); } }
查看进程、线程
windows
- 任务管理器
- 命令行，输入tasklist
- 命令行taskkill，杀死进程
linux
- 查看所有进程：ps -ef
- 查看某个进程的所有线程：ps -fT -p 进程id
- top
- 查看线程：top -H -p 进程id
jdk
-
jps
-
jstack 进程id
-
jconsole
win+r，输入jconsole，可选本地连接、远程连接（输入ip:端口）
常用方法
| 方法名 | static | 功能说明 | 注意 |
|---|---|---|---|
| start() | 启动一个新线程，在新的线程运行 run 方法中的代码 | start 方法只是让线程进入就绪，里面代码不一定立刻运行（CPU 的时间片还没分给它）。每个线程对象的start方法只能调用一次，如果调用了多次会出现IllegalThreadStateException | |
| run() | 新线程启动后会调用的方法 | 如果在构造 Thread 对象时传递了 Runnable 参数，则线程启动后会调用 Runnable 中的 run 方法，否则默认不执行任何操作。但可以创建 Thread 的子类对象，来覆盖默认行为 | |
| join() | 等待线程运行结束 | 释放锁 | |
| join(long n) | 等待线程运行结束,最多等待 n 毫秒 | 如果n>线程实际运行用时，则会提前结束等待；释放锁 | |
| getId() | 获取线程长整型的 id | id 唯一 | |
| getName() | 获取线程名 | ||
| setName(String name) | 修改线程名 | ||
| getPriority() | 获取线程优先级 | ||
| setPriority(int priority) | 修改线程优先级 | java中规定线程优先级是1~10 的整数，较大的优先级能提高该线程被 CPU 调度的机率 | |
| getState() | 获取线程状态 | Java 中线程状态是用 6 个 enum 表示，分别为 NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED | |
| isInterrupted() | 判断是否被打断 | 不会清除打断标记 | |
| isAlive() | 线程是否存活（还没有运行完毕） | ||
| interrupt() | 打断线程 | 如果被打断线程正在 sleep，wait，join 会导致被打断的线程抛出 InterruptedException，并清除打断标记为false ；如果打断的正在运行的线程，则会设置打断标记为true ；park 的线程被打断，也会设置打断标记 | |
| interrupted() | static | 判断当前线程是否被打断 | 会清除打断标记 |
| currentThread() | static | 获取当前正在执行的线程 | |
| sleep(long n) | static | 让当前执行的线程休眠n毫秒，休眠时让出cpu 的时间片给其它线程 | 线程从running进入timed waiting状态；不会释放锁； 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性 |
| yield() | static | 提示线程调度器让出当前线程对CPU的使用，使线程占用的时间片减少 | 线程从running进入runnable就绪状态；主要是为了测试和调试；不会释放锁 |
sleep应用
run方法执行死循环，防止cpu利用率到100%
while(true) {
try {
Thread.sleep(50);//睡眠一小段时间
} catch(InterruptedException e) {
e.printStackTrace();
}
}
join应用
调用多个线程的join方法，同步等待多个结果，最终耗时取决于用时最大的线程，不取决于线程join顺序
static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {
test2();
}
private static void test2() throws InterruptedException {
Thread t1 = new Thread(() -> {
sleep(1);
r1 = 10;
});
Thread t2 = new Thread(() -> {
sleep(2);
r2 = 20;
});
long start = System.currentTimeMillis();
t1.start();
t2.start();
t1.join();
t2.join();
long end = System.currentTimeMillis();
log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}
interrupt应用
打断 sleep，wait，join 的线程
Thread t1 = new Thread(()->{
Thread.sleep(1000);
}, "t1");
t1.start();
Thread.sleep(500);
t1.interrupt();
log.debug(" 打断状态: {}", t1.isInterrupted());
打断正在运行的线程
Thread t1=new Thread(()-> {
while(true) {
boolean flag=Thread.currentThread().isInterrupted();
if(flag) {
log.debug("interrupted");
break;
}
}
},"t1");
t1.start();
Thread.sleep(1000);
t1.interrupted();
打断park线程
Thread t1 = new Thread(() -> {
log.debug("park...");
LockSupport.park();
log.debug("unpark...");
log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
//可以用Thread.interrupted()清空打断标志，使park()重新生效
}, "t1");
t1.start();
Thread.sleep(500);
t1.interrupt();
过时方法
容易破坏同步代码块，造成线程死锁
- stop()停止线程运行
- suspend()挂起（暂停）线程运行
- resume()恢复线程运行
守护线程/后台线程
只要其它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束
log.debug("开始运行...");
Thread t1 = new Thread(() -> {
log.debug("开始运行...");
Thread.sleep(2000);
log.debug("运行结束...");
}, "daemon");
// 设置该线程为守护线程
t1.setDaemon(true);
t1.start();
Thread.sleep(1000);
log.debug("运行结束...");
三 共享模型之管程
临界区
存在对共享资源的多线程读写操作的一段代码块
在多个线程对共享资源读写操作时发生指令交错，会出现并发问题
static int count=0;
//临界区
static void m() {
count++;
}
竞态条件
多个线程在临界区内执行，由于代码的执行序列（字节码指令执行顺序）不同而导致结果无法预测，叫做发生了竞态条件
synchronized代码块
采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住，用对象锁保证临界区内代码的原子性
某个线程获取对象锁，即使时间片用完也不会释放锁，其它线程仍然阻塞
@Slf4j(topic = "c.Test3")
public class Test3 {
static int count = 0;
static Object lock = new Object();
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
//申请获得对象锁
synchronized (lock) {
count++;
}
}
}, "t1");
Thread t2 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
//申请获得对象锁
synchronized (lock) {
count--;
}
}
}, "t2");
t1.start();
t2.start();
t1.join();
t2.join();
log.debug("{}", count);
}
}
面向对象改进
@Slf4j(topic = "c.Test3")
public class Test3 {
public static void main(String[] args) throws InterruptedException {
Room room = new Room();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
room.increment();
}
}, "t1");
Thread t2 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
room.decrement();
}
}, "t2");
t1.start();
t2.start();
t1.join();
t2.join();
log.debug("{}", room.getCount());
}
}
class Room {
private int count = 0;
public void increment() {
synchronized (this) {
count++;
}
}
public void decrement() {
synchronized (this) {
count--;
}
}
public int getCount() {
synchronized (this) {
return count;
}
}
}
synchronized方法
-
加在非静态方法等价于锁住this对象
class Test { public synchronized void m() {} } 等价于 class Test { public void m() { synchronized(this) {} } } -
加在静态方法等价于锁住类对象
class Test { public synchronized static void m() {} } 等价于 class Test { public static void m() { synchronized(Test.class) {} } }
变量的线程安全
成员变量和静态变量
- 没有共享，则线程安全
- 有共享，只有读操作，则线程安全
- 有共享，有读写操作，则线程不一定安全
局部变量
- 局部变量没有引用对象，则线程安全
- 局部变量引用对象，没有逃离方法的作用范围，则线程安全
- 局部变量引用对象，逃离方法的作用范围，则线程不一定安全
可以在父类使用private, final修饰方法，不让子类覆盖，提高父类的线程安全性
常见线程安全类
多个线程调用它们同一个实例的某个方法时是线程安全的，但使用线程安全类方法的组合则线程不一定安全
- String
- Integer
- StringBuffer
- Random
- Vector
- HashTable
- java.util.concurrent包下的类
wait-notify
原理
- Owner 线程发现条件不满足，调用 wait 方法，即可进入 WaitSet 变为 WAITING 状态
- BLOCKED 和 WAITING 的线程都处于阻塞状态，不占用 CPU 时间片
- BLOCKED 线程会在 Owner 线程释放锁时唤醒
- WAITING 线程会在 Owner 线程调用 notify 或 notifyAll 时唤醒，但唤醒后并不意味者立刻获得锁，仍需进入 EntryList 重新竞争
使用
下面都属于 Object 对象的方法。必须获得此对象的锁，才能调用这几个方法
- obj.wait() 让进入 object 监视器的线程到 waitSet 等待
- obj.wait(long n) 等待一定时间后唤醒
- obj.notify() 在 object 上正在 waitSet 等待的线程中挑一个唤醒
- obj.notifyAll() 让 object 上正在 waitSet 等待的线程全部唤醒
@Slf4j(topic = "c.Test4")
public class Test4 {
final static Object obj=new Object();
public static void main(String[] args) throws InterruptedException {
new Thread(()-> {
synchronized (obj) {
log.debug("执行");
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
log.debug("其它代码");
}
},"t1").start();
new Thread(()-> {
synchronized (obj) {
log.debug("执行");
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
log.debug("其它代码");
}
},"t2").start();
Thread.sleep(2000);
log.debug("唤醒obj上其它线程");
synchronized (obj) {
obj.notify();//唤醒obj上一个线程
// obj.notifyAll();// 唤醒obj上所有等待线程
}
}
}
synchronized(lock) {
while(条件不成立) {
lock.wait();
}
// 干活
}
//另一个线程
synchronized(lock) {
lock.notifyAll();
}
sleep和wait对比
- sleep是Thread方法，wait是Object方法
- sleep不需要和synchronized配合使用，wait需要和synchronized配合使用
- sleep不会释放对象锁，wait会释放对象锁
- sleep通常被用于暂停执行，wait通常被用于线程间交互/通信
park&unpark
使用
- 以线程为单位阻塞、唤醒线程
- 不需要获得对象锁
- unpark可以在park之前或之后调用
@Slf4j(topic = "c.Test7")
public class Test7 {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
log.debug("start");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.debug("park");
LockSupport.park();
log.debug("resume");
}, "t1");
t1.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.debug("unpark");
LockSupport.unpark(t1);
}
}
原理
每个线程都有自己的一个 Parker 对象，由三部分组成 _counter ， _cond 和 _mutex
先park后unpark:
先unpark后park:
死锁
概述
多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放
public class DeadLockDemo {
private static Object resource1 = new Object();//资源1
private static Object resource2 = new Object();//资源2
public static void main(String[] args) {
new Thread(() -> {
synchronized (resource1) {
System.out.println(Thread.currentThread() + "get resource1");
try {
Thread.sleep(1000);//让线程2得到执行然后获取到资源2的锁
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread() + "waiting get resource2");
synchronized (resource2) {
System.out.println(Thread.currentThread() + "get resource2");
}
}
}, "线程1").start();
new Thread(() -> {
synchronized (resource2) {
System.out.println(Thread.currentThread() + "get resource2");
try {
Thread.sleep(1000);//让线程1得到执行然后获取到资源1的锁
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread() + "waiting get resource1");
synchronized (resource1) {
System.out.println(Thread.currentThread() + "get resource1");
}
}
}, "线程2").start();
}
}
产生死锁的四个必要条件：
- 互斥
- 占有且等待
- 不可抢占
- 循环等待
定位
- jstack
- 运行程序后，在终端输入jps，查找运行进程
- 输入jstack 进程id
- 输出结果最后会提示死锁线程以及死锁位置
- jconsole
- 打开jconsole，选择运行进程
- 查看线程页面
- 点击检测死锁
预防
- 破坏占有且等待条件 ：一次性申请所有的资源。
- 破坏不可抢占条件 ：占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
- 破坏循环等待条件 ：靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。
避免
在资源分配时，借助于算法（比如银行家算法）对资源分配进行计算评估，使其进入安全状态
安全状态指的是系统能够按照某种进行推进顺序（P1、P2、P3…Pn）来为每个进程分配所需资源，直到满足每个进程对资源的最大需求，使每个进程都可顺利完成。称<P1、P2、P3…Pn>序列为安全序列
对线程 2 的代码修改成下面这样就不会产生死锁了
new Thread(() -> {
synchronized (resource1) {
System.out.println(Thread.currentThread() + "get resource1");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread() + "waiting get resource2");
synchronized (resource2) {
System.out.println(Thread.currentThread() + "get resource2");
}
}
}, "线程 2").start();
活锁
出现在两个线程互相改变对方的结束条件，最后谁也无法结束
public class Test9 {
static volatile int count = 10;
public static void main(String[] args) {
new Thread(() -> {
// 期望减到 0 退出循环
while (count > 0) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println("count=" + count);
}
}, "t1").start();
new Thread(() -> {
// 期望超过 20 退出循环
while (count < 20) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count++;
System.out.println("count=" + count);
}
}, "t2").start();
}
}
一个解决方案：使两个线程的睡眠时间不同
饥饿
一个线程由于优先级太低，始终得不到 CPU 调度执行，也不能够结束
ReentrantLock
使用
//创建ReentrantLock对象
// 获取锁
reentrantLock.lock();
try {
// 临界区
} finally {
// 释放锁
reentrantLock.unlock();
}
synchronized 和 ReentrantLock 的区别
-
都是可重入锁
-
synchronized 依赖于 JVM 而 ReentrantLock 依赖于 API
-
ReentrantLock相比synchronized
等待可中断
可以设置超时时间
可实现公平锁
支持多个条件变量
可重入
同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁
@Slf4j(topic = "c.Test10")
public class Test10 {
private static ReentrantLock lock=new ReentrantLock();
public static void main(String[] args) {
lock.lock();
try {
log.debug("enter main");
m1();
} finally {
lock.unlock();
}
}
public static void m1() {
lock.lock();
try {
log.debug("enter m1");
m2();
} finally {
lock.unlock();
}
}
public static void m2() {
lock.lock();
try {
log.debug("enter m2");
} finally {
lock.unlock();
}
}
}
可打断
一个线程获得锁，其它线程需要等待，等待可以被打断，防止无限等待
@Slf4j(topic = "c.Test10")
public class Test10 {
private static ReentrantLock lock=new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
Thread t1=new Thread(()-> {
try {
log.debug("尝试获取到锁");
lock.lockInterruptibly();
} catch (InterruptedException e) {
log.debug("没有获取到锁");
e.printStackTrace();
return;
}
try {
log.debug("获取到锁");
} finally {
lock.unlock();
}
},"t1");
lock.lock();
t1.start();
Thread.sleep(1000);
log.debug("打断t1");
t1.interrupt();
}
}
锁超时
一个线程获得锁，其它线程需要等待，等待一段时间后不再等待，放弃获取锁
@Slf4j(topic = "c.Test10")
public class Test10 {
private static ReentrantLock lock=new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
Thread t1=new Thread(()-> {
log.debug("尝试获取到锁");
try {
if (!lock.tryLock(2, TimeUnit.SECONDS)) {
log.debug("没有获取到锁");
return;
}
} catch (InterruptedException e) {
e.printStackTrace();
log.debug("没有获取到锁");
return;
}
try {
log.debug("获取到锁");
} finally {
lock.unlock();
}
},"t1");
lock.lock();
log.debug("获取到锁");
t1.start();
Thread.sleep(1000);
log.debug("释放锁");
lock.unlock();
}
}
公平锁
线程等待获取锁，按照进入阻塞队列的顺序获取锁
公平锁一般没有必要，会降低并发度
ReentrantLock lock = new ReentrantLock(true);
条件变量
相当于synchronized的waitSet 休息室，当条件不满足时进入 waitSet 等待，ReentrantLock支持多个条件变量
- await 前需要获得锁
- await 执行后，会释放锁，进入 conditionObject 等待
- await 的线程被唤醒（或打断、或超时）取重新竞争 lock 锁
- 竞争 lock 锁成功后，从 await 后继续执行
@Slf4j(topic = "c.Test10")
public class Test10 {
static ReentrantLock lock = new ReentrantLock();
static Condition waitCigaretteQueue = lock.newCondition();
static volatile boolean hasCigrette = false;
public static void main(String[] args) throws InterruptedException {
new Thread(()-> {
lock.lock();
try {
while(!hasCigrette) {
log.debug("没烟，休息下");
try {
waitCigaretteQueue.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
log.debug("等到烟了，干活");
} finally {
lock.unlock();
}
},"t1").start();
Thread.sleep(1000);
new Thread(()-> {
lock.lock();
try {
hasCigrette=true;
waitCigaretteQueue.signal();
log.debug("烟来了");
} finally {
lock.unlock();
}
},"送烟的").start();
}
}
应用
互斥：使用 synchronized 或 Lock 达到共享资源互斥效果
同步：使用 wait/notify 或 Lock 的条件变量来达到线程间通信效果
扫一扫
1581
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
