并发编程已完结，章节如下：
Java 并发编程一篇 -（Synchronized 原理、LockSupport 原理、ReentrantLock 原理）
Java 并发编程二篇 -（JMM、CAS 原理、Volatile 原理）
Java 并发编程三篇 -（线程池）
Java 并发编程四篇 -（JUC、AQS 源码、ReentrantLock 源码）
进程
线程
两者对比
并发（concurrent）是同一时间应对（dealing with）多件事情的能力
并行（parallel）是同一时间动手做（doing）多件事情的能力
同步和异步的概念
以调用方的角度讲，如果
方法一，使用 Thread
// 创建线程对象,匿名内部类方式创建 Thread
Thread t = new Thread() {
@Override
public void run() {
// 要执行的任务
}
};
// 启动线程
t.start();
方法二，使用 Runnable 配合 Thread（推荐）
Runnable runnable = new Runnable() {
public void run(){
// 要执行的任务
}
};
// 创建线程对象
Thread t = new Thread( runnable );
// 启动线程
t.start();
public static void main(String[] args) {
// 使用 lambda 表达式，因为 Runnable 接口
// 标注了 @FunctionalInterface 这个注解，表示是一个函数式接口，可以使用 lambda 表达式
Runnable r = () -> log.debug("running");
new Thread(r, "t1").start();
}
比较方法一和方法二：
方法三，FutureTask 配合 Thread
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 1. 使用 FutureTask 传入 Callable 接口方式创建
FutureTask<Integer> future = new FutureTask<Integer>(() -> {
log.debug("running...");
Thread.sleep(2000); // 休眠
return 100;
});
// 2. 传入 future, 因为 FutureTask 这个类是实现了 RunnableFuture 接口，RunnableFuture 继承了 Runnable 接口
Thread t1 = new Thread(future, "t1");
t1.start();
// 3. 获取返回结果时
// 当主线程获取 t1 线程的返回值时, 需要等 2 秒，此时主线程进入阻塞状态
log.debug("{}", future.get());
}
public interface Future<V> {
// 取消任务
boolean cancel(boolean mayInterruptIfRunning);
// 获取任务执行结果
V get() throws InterruptedException, ExecutionException;
// 获取任务执行结果，带有超时时间限制
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
// 判断任务是否已经取消
boolean isCancelled();
// 判断任务是否已经结束
boolean isDone();
}
栈与栈帧
虚拟机栈描述的是Java方法执行的内存模型：
线程上下文切换（Thread Context Switch）
因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码
被动原因：
主动原因：
当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念 就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的。
sleep (使线程阻塞)
yield （让出当前线程）
Thread t1 = new Thread();
//等待 t1 线程执行结束
t1.join();
// 最多等待 1000ms,如果 1000ms 内线程执行完毕，则会直接执行下面的语句，不会等够 1000ms
t1.join(1000);
interrupt 打断线程有两种情况，如下：
isInterrupted() 与 interrupted() 比较，如下：
细节：
终止模式之两阶段终止模式，如下：
/**
* 使用 interrupt 进行两阶段终止模式
*/
@Slf4j(topic = "c.Code_13_Test")
public class Code_13_Test {
public static void main(String[] args) throws InterruptedException {
TwoParseTermination twoParseTermination = new TwoParseTermination();
twoParseTermination.start();
Thread.sleep(3500);
twoParseTermination.stop();
}
}
@Slf4j(topic = "c.TwoParseTermination")
class TwoParseTermination {
private Thread monitor;
// 启动线程
public void start() {
monitor = new Thread(() -> {
while (true) {
Thread thread = Thread.currentThread();
if(thread.isInterrupted()) { // 调用 isInterrupted 不会清除标记
log.info("料理后事 ...");
break;
} else {
try {
Thread.sleep(1000);
log.info("执行监控的功能 ...");
} catch (InterruptedException e) {
log.info("设置打断标记 ...");
thread.interrupt();
e.printStackTrace();
}
}
}
}, "monitor");
monitor.start();
}
// 终止线程
public void stop() {
monitor.interrupt();
}
}
从操作系统层划分，线程有 5 种状态
这是从 Java API 层面来描述的，我们主要研究的就是这种。可以参考文章，点这里
/**
* 演示 java 线程的 6 种状态(NEW, RUNNABLE, TERMINATED, BLOCKED, WAITING, TIMED_WAITING)
*/
@Slf4j(topic = "c.Code_15_Test")
public class Code_15_Test {
public static void main(String[] args) {
// NEW
Thread t1 = new Thread(() -> {
log.info("NEW 状态");
}, "t1");
// RUNNABLE
Thread t2 = new Thread(() -> {
while (true) {
}
}, "t2");
t2.start();
// TERMINATED
Thread t3 = new Thread(() -> {
log.info("running");
}, "t3");
t3.start();
// TIMED_WAITING
Thread t4 = new Thread(() -> {
synchronized (Code_15_Test.class) {
try {
Thread.sleep(100000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "t4");
t4.start();
// WAITING
Thread t5 = new Thread(() -> {
try {
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "t5");
t5.start();
Thread t6 = new Thread(() -> {
synchronized (Code_15_Test.class) {
try {
Thread.sleep(100000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "t6");
t6.start();
// 主线程休眠 1 秒, 目的是为了等待 t3 线程执行完
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info("t1 线程状态: {}", t1.getState());
log.info("t2 线程状态: {}", t2.getState());
log.info("t3 线程状态: {}", t3.getState());
log.info("t4 线程状态: {}", t4.getState());
log.info("t5 线程状态: {}", t5.getState());
log.info("t6 线程状态: {}", t6.getState());
}
}
本章的重点在于掌握
1）线程的创建
2）线程重要的 API，如 start、run、sleep、yield、join、interrupt 等
3）线程的状态
4）原理方面，线程的运行流程，栈、栈帧、上下文切换、程序计数器等知识。
5）Thread 两种创建线程的源码
6）使用 interrupt 来编写两阶段终止
线程出现问题的根本原因是因为线程上下文切换，导致线程里的指令没有执行完就切换执行其它线程了。
public static int count = 0;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 1;i < 5000; i++){
count++;
}
});
Thread t2 = new Thread(() -> {
for (int i = 1;i < 5000; i++){
count--;
}
});
t1.start();
t2.start();
t1.join();
t2.join();
log.debug("count的值是{}",count);
}
如上代码，当执行 count++ 或者 count-- 操作的时候，从字节码分析，实际上是 4 步操作。
count++; // 操作字节码如下：
getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
iadd // 自增
putstatic i // 将修改后的值存入静态变量i
count--; // 操作字节码如下：
getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
isub // 自减
putstatic i // 将修改后的值存入静态变量i
例如，下面代码中的临界区
static int counter = 0;
static void increment()
// 临界区
{
counter++;
}
static void decrement()
// 临界区
{
counter--;
}
synchronized(对象) {
//临界区
}
public class Test {
// 在方法上加上synchronized关键字
public synchronized void test() {
}
// 等价于
public void test() {
synchronized(this) { // 锁住的是对象
}
}
}
public class Test {
// 在静态方法上加上 synchronized 关键字
public synchronized static void test() {
}
//等价于
public void test() {
synchronized(Test.class) { // 锁住的是类
}
}
}
任何一个类只要没有成员变量，就是线程安全的。
解释：
因为成员方法是每个线程私有的，而我们常说的线程安全问题就是我们通过成员方法访问了成员变量，从而造成了线程之间成员变量状态不一致的问题，所以只要没有成员变量，就不会有不一致问题，从而也就不会有线程安全问题。
至于为什么访问了成员变量就会有线程安全问题: 是因为成员变量的对象分配是在堆内存中的，所以是为所有线程所共享的，所以可能会被多个线程同时访问，从而造成线程不安全
类的私有成员变量，若是多例则是线程私有，若单例则全局共享
public static void test() {
int i = 10;
i++;
}
@Slf4j(topic = "c.Code_18_Test")
public class Code_18_Test {
public static void main(String[] args) {
UnsafeTest unsafeTest = new UnsafeTest();
for(int i = 0; i < 10; i++) {
new Thread(() -> {
unsafeTest.method1();
}, "t" + i).start();
}
}
}
class UnsafeTest {
List<Integer> list = new ArrayList<>();
public void method1() {
for (int i = 0; i < 200; i++) {
method2();
method3();
}
}
public void method2() {
list.add(1);
}
public void method3() {
list.remove(0);
}
}
class SafeTest {
public void method1() {
List<Integer> list = new ArrayList<>();
for (int i = 0; i < 200; i++) {
method2(list);
method3(list);
}
}
public void method2(List<Integer> list) {
list.add(1);
}
public void method3(List<Integer> list) {
list.remove(0);
}
}
class UnsafeSubTest extends UnsafeTest {
@Override
public void method3(List<Integer> list) {
new Thread(() -> {
list.remove(0);
}).start();
}
}
class ThreadSafe {
public final void method1(int loopNumber) {
ArrayList<String> list = new ArrayList<>();
for (int i = 0; i < loopNumber; i++) {
method2(list);
method3(list);
}
}
private void method2(ArrayList<String> list) {
list.add("1");
}
private void method3(ArrayList<String> list) {
list.remove(0);
}
}
class ThreadSafeSubClass extends ThreadSafe{
@Override
public void method3(ArrayList<String> list) {
new Thread(() -> {
list.remove(0);
}).start();
}
}
Hashtable table = new Hashtable();
new Thread(()->{
table.put("key1", "value1");
}).start();
new Thread(()->{
table.put("key2", "value2");
}).start();
Hashtable table = new Hashtable();
// 线程1，线程2
if( table.get("key") == null) {
table.put("key", value);
}
public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > value.length) {
throw new StringIndexOutOfBoundsException(endIndex);
}
int subLen = endIndex - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return ((beginIndex == 0) && (endIndex == value.length)) ? this
: new String(value, beginIndex, subLen); // 新建一个对象，然后返回，没有修改等操作，是线程安全的。
}
示例一：
@Aspect
@Component
public class MyAspect {
// 是否安全？
private long start = 0L;
@Before("execution(* *(..))")
public void before() {
start = System.nanoTime();
}
@After("execution(* *(..))")
public void after() {
long end = System.nanoTime();
System.out.println("cost time:" + (end-start));
}
}
示例二：
public class MyServlet extends HttpServlet {
// 是否安全
private UserService userService = new UserServiceImpl();
public void doGet(HttpServletRequest request, HttpServletResponse response) {
userService.update(...);
}
}
public class UserServiceImpl implements UserService {
// 是否安全
private UserDao userDao = new UserDaoImpl();
public void update() {
userDao.update();
}
}
public class UserDaoImpl implements UserDao {
public void update() {
String sql = "update user set password = ? where username = ?";
// 是否安全
try (Connection conn = DriverManager.getConnection("","","")){
// ...
} catch (Exception e) {
// ...
}
}
}
示例三：
public class MyServlet extends HttpServlet {
// 是否安全
private UserService userService = new UserServiceImpl();
public void doGet(HttpServletRequest request, HttpServletResponse response) {
userService.update(...);
}
}
public class UserServiceImpl implements UserService {
// 是否安全
private UserDao userDao = new UserDaoImpl();
public void update() {
userDao.update();
}
}
public class UserDaoImpl implements UserDao {
// 是否安全
private Connection conn = null;
public void update() throws SQLException {
String sql = "update user set password = ? where username = ?";
conn = DriverManager.getConnection("","","");
// ...
conn.close();
}
}
示例四：
public class MyServlet extends HttpServlet {
// 是否安全
private UserService userService = new UserServiceImpl();
public void doGet(HttpServletRequest request, HttpServletResponse response) {
userService.update(...);
}
}
public class UserServiceImpl implements UserService {
public void update() {
UserDao userDao = new UserDaoImpl();
userDao.update();
}
}
public class UserDaoImpl implements UserDao {
// 是否安全
private Connection = null;
public void update() throws SQLException {
String sql = "update user set password = ? where username = ?";
conn = DriverManager.getConnection("","","");
// ...
conn.close();
}
}
示例五：
public abstract class Test {
public void bar() {
// 是否安全
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
foo(sdf);
}
public abstract foo(SimpleDateFormat sdf);
public static void main(String[] args) {
new Test().bar();
}
}
public void foo(SimpleDateFormat sdf) {
String dateStr = "1999-10-11 00:00:00";
for (int i = 0; i < 20; i++) {
new Thread(() -> {
try {
sdf.parse(dateStr);
} catch (ParseException e) {
e.printStackTrace();
}
}).start();
}
}
普通对象
数组对象
其中 Mark Word 结构为
64 位虚拟机 Mark Word
参考文章
参考文章
轻量级锁的使用场景是：如果一个对象虽然有多个线程要对它进行加锁，但是加锁的时间是错开的（也就是没有人可以竞争的），那么可以使用轻量级锁来进行优化。轻量级锁对使用者是透明的，即语法仍然是 synchronized ，假设有两个方法同步块，利用同一个对象加锁
static final Object obj = new Object();
public static void method1() {
synchronized( obj ) {
// 同步块 A
method2();
}
}
public static void method2() {
synchronized( obj ) {
// 同步块 B
}
}
如果在尝试加轻量级锁的过程中，cas 操作无法成功，这是有一种情况就是其它线程已经为这个对象加上了轻量级锁，这是就要进行锁膨胀，将轻量级锁变成重量级锁。
static Object obj = new Object();
public static void method1() {
synchronized( obj ) {
// 同步块
}
}
重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即在自旋的时候持锁的线程释放了锁），那么当前线程就可以不用进行上下文切换就获得了锁
在轻量级的锁中，我们可以发现，如果同一个线程对同一个对象进行重入锁时，也需要执行 CAS 操作，这是有点耗时滴，那么 java6 开始引入了偏向锁的东东，只有第一次使用 CAS 时将对象的 Mark Word 头设置为偏向线程 ID，之后这个入锁线程再进行重入锁时，发现线程 ID 是自己的，那么就不用再进行CAS了。
static final Object obj = new Object();
public static void m1() {
synchronized(obj) {
// 同步块 A
m2();
}
}
public static void m2() {
synchronized(obj) {
// 同步块 B
m3();
}
}
public static void m3() {
synchronized(obj) {
// 同步块 C
}
}
以下几种情况会使对象的偏向锁失效
- 因为偏向锁的线程ID占用了无锁状态下的hashcode的位置。调用object.hashCode()就会把对象头中存储的线程ID清空，用来存储hashCode。
- 为什么轻量级锁和重量级锁对象调用object.hashCode()时，轻量级锁和重量级锁不会失效？
- 因为轻量级锁对象的hashCode存储在线程栈帧的Lock recode中；重量级锁对象的hashCode存储在Mointer中，解锁时会还原。而偏向级锁没有额外的存储空间
什么时候适合使用wait
使用wait/notify需要注意什么
synchronized (lock) {
while(不满足条件，一直循环等待，避免虚假唤醒) {
lock.wait();
}
//满足条件后再运行
}
synchronized (lock) {
//唤醒所有等待线程
lock.notifyAll();
}
即 Guarded Suspension，用在一个线程等待另一个线程的执行结果，要点：
多任务版 GuardedObject 图中 Futures 就好比居民楼一层的信箱（每个信箱有房间编号），左侧的 t0，t2，t4 就好比等待邮件的居民，右侧的 t1，t3，t5 就好比邮递员如果需要在多个类之间使用 GuardedObject 对象，作为参数传递不是很方便，因此设计一个用来解耦的中间类，这样不仅能够解耦【结果等待者】和【结果生产者】，还能够同时支持多个任务的管理。和生产者消费者模式的区别就是：这个生产者和消费者之间是一一对应的关系，但是生产者消费者模式并不是。rpc 框架的调用中就使用到了这种模式。
代码如下：
/**
* 同步模式-保护性暂停 (Guarded-Suspension-pattern)
*/
@Slf4j(topic = "c.Code_23_Test")
public class Code_23_Test {
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
new People().start();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
for(Integer id : Mailboxes.getIds()) {
new Postman(id, "内容 " + id).start();
}
}
}
@Slf4j(topic = "c.People")
class People extends Thread {
@Override
public void run() {
GuardedObject guardedObject = Mailboxes.createGuardedObject();
log.info("收信的为 id: {}", guardedObject.getId());
Object o = guardedObject.get(5000);
log.info("收到信的 id: {}, 内容: {}", guardedObject.getId(), o);
}
}
@Slf4j(topic = "c.Postman")
class Postman extends Thread {
private int id;
private String mail;
public Postman(int id, String mail) {
this.id = id;
this.mail = mail;
}
@Override
public void run() {
GuardedObject guardedObject = Mailboxes.getGuardedObject(id);
log.info("送信的 id: {}, 内容: {}", id, mail);
guardedObject.complete(mail);
}
}
class Mailboxes {
private static int id = 1;
private static Map<Integer, GuardedObject> boxes = new Hashtable<>();
public static synchronized int generateId() {
return id++;
}
// 用户会进行投信
public static GuardedObject createGuardedObject() {
GuardedObject guardedObject = new GuardedObject(generateId());
boxes.put(guardedObject.getId(), guardedObject);
return guardedObject;
}
// 派件员会派发信
public static GuardedObject getGuardedObject(int id) {
return boxes.remove(id);
}
public static Set<Integer> getIds() {
return boxes.keySet();
}
}
class GuardedObject {
private int id;
public GuardedObject(int id) {
this.id = id;
}
public int getId() {
return this.id;
}
private Object response;
// 优化等待时间
public Object get(long timeout) {
synchronized (this) {
long begin = System.currentTimeMillis();
long passTime = 0;
while (response == null) {
long waitTime = timeout - passTime; // 剩余等待时间
if(waitTime <= 0) {
break;
}
try {
this.wait(waitTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
passTime = System.currentTimeMillis() - begin;
}
return response;
}
}
public void complete(Object response) {
synchronized (this) {
this.response = response;
this.notify();
}
}
}
// 暂停当前线程
LockSupport.park();
// 恢复某个线程的运行
LockSupport.unpark;
如果备用干粮耗尽，那么钻进帐篷歇息
如果备用干粮充足，那么不需停留，继续前进
如果这时线程还在帐篷，就唤醒让他继续前进
如果这时线程还在运行，那么下次他调用 park 时，仅是消耗掉备用干粮，不需停留继续前进
因为背包空间有限，多次调用 unpark 仅会补充一份备用干粮
先调用park再调用upark的过程
当前线程调用 Unsafe.park() 方法
检查 _counter ，本情况为 0，这时，获得 _mutex，互斥锁(mutex对象有个等待队列 _cond)
线程进入 _cond 条件变量阻塞
设置 _counter = 0
调用 Unsafe.unpark(Thread_0) 方法
设置 _counter 为 1 唤醒 _cond 条件变量中的 Thread_0
Thread_0 恢复运行
设置 _counter 为 0
先调用upark再调用park的过程
调用 Unsafe.unpark(Thread_0) 方法
设置 _counter 为 1
当前线程调用 Unsafe.park() 方法
检查 _counter ，本情况为 1，这时线程无需阻塞，继续运行
设置 _counter 为 0
当调用了 t.start() 方法时，由 NEW –> RUNNABLE
- 当调用了t 线程用 synchronized(obj) 获取了对象锁后，调用 obj.wait() 方法时，t 线程从 RUNNABLE –> WAITING
- 调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时，会在 WaitSet 等待队列中出现锁竞争，非公平竞争
竞争锁成功，t 线程从 WAITING –> RUNNABLE
竞争锁失败，t 线程从 WAITING –> BLOCKED
- 当前线程调用 t.join() 方法时，当前线程从 RUNNABLE –> WAITING
注意是当前线程在 t 线程对象的监视器上等待- t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 WAITING –> RUNNABLE
- 当前线程调用 LockSupport.park() 方法会让当前线程从 RUNNABLE –> WAITING
- 调用 LockSupport.unpark(目标线程) 或调用了线程 的 interrupt() ，会让目标线程从 WAITING –> RUNNABLE
- t 线程用 synchronized(obj) 获取了对象锁后, 调用 obj.wait(long n) 方法时，t 线程从 RUNNABLE –> TIMED_WAITING
- t 线程等待时间超过了 n 毫秒，或调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时
竞争锁成功，t 线程从 TIMED_WAITING –> RUNNABLE
竞争锁失败，t 线程从 TIMED_WAITING –> BLOCKED
- 当前线程调用 t.join(long n) 方法时，当前线程从 RUNNABLE –> TIMED_WAITING
注意是当前线程在 t 线程对象的监视器上等待- 当前线程等待时间超过了 n 毫秒，或 t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 TIMED_WAITING –> RUNNABLE
- 当前线程调用 Thread.sleep(long n) ，当前线程从 RUNNABLE –> TIMED_WAITING
- 当前线程等待时间超过了 n 毫秒，当前线程从 TIMED_WAITING –> RUNNABLE
- 当前线程调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis) 时，当前线 程从 RUNNABLE –> TIMED_WAITING
- 调用 LockSupport.unpark(目标线程) 或调用了线程 的 interrupt() ，或是等待超时，会让目标线程从 TIMED_WAITING–> RUNNABLE
- t 线程用 synchronized(obj) 获取了对象锁时如果竞争失败，从 RUNNABLE –> BLOCKED
- 持 obj 锁线程的同步代码块执行完毕，会唤醒该对象上所有 BLOCKED 的线程重新竞争，如果其中 t 线程竞争 成功，从 BLOCKED –> RUNNABLE ，其它失败的线程仍然 BLOCKED
- 当前线程所有代码运行完毕，进入 TERMINATED
public static void main(String[] args) {
final Object A = new Object();
final Object B = new Object();
new Thread(()->{
synchronized (A) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (B) {
}
}
}).start();
new Thread(()->{
synchronized (B) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (A) {
}
}
}).start();
}
在一段时间内，一种资源只能被一个进程所使用
进程已经拥有了至少一种资源，同时又去申请其他资源。因为其他资源被别的进程所使用，该进程进入阻塞状态，并且不释放自己已有的资源
进程对已获得的资源在未使用完成前不能被强占，只能在进程使用完后自己释放
发生死锁时，必然存在一个进程——资源的循环链。
- 死锁是因为线程互相持有对象想要的锁，并且都不释放，最后到时线程阻塞，停止运行的现象。
- 活锁是因为线程间修改了对方的结束条件，而导致代码一直在运行，却一直运行不完的现象。
- 可中断
- 可以设置超时时间
- 可以设置为公平锁 (先到先得)
- 支持多个条件变量( 具有多个 WaitSet)
// 获取ReentrantLock对象
private ReentrantLock lock = new ReentrantLock();
// 加锁
lock.lock();
try {
// 需要执行的代码
}finally {
// 释放锁
lock.unlock();
}
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
try {
// 加锁，可打断锁
lock.lockInterruptibly();
} catch (InterruptedException e) {
e.printStackTrace();
// 被打断，返回，不再向下执行
return;
}finally {
// 释放锁
lock.unlock();
}
});
lock.lock();
try {
t1.start();
Thread.sleep(1000);
// 打断
t1.interrupt();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
不设置等待时间
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
// 未设置等待时间，一旦获取失败，直接返回false
if(!lock.tryLock()) {
System.out.println("获取失败");
// 获取失败，不再向下执行，返回
return;
}
System.out.println("得到了锁");
lock.unlock();
});
lock.lock();
try{
t1.start();
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
设置等待时间
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
try {
// 判断获取锁是否成功，最多等待1秒
if(!lock.tryLock(1, TimeUnit.SECONDS)) {
System.out.println("获取失败");
// 获取失败，不再向下执行，直接返回
return;
}
} catch (InterruptedException e) {
e.printStackTrace();
// 被打断，不再向下执行，直接返回
return;
}
System.out.println("得到了锁");
// 释放锁
lock.unlock();
});
lock.lock();
try{
t1.start();
// 打断等待
t1.interrupt();
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
// 默认是不公平锁，需要在创建时指定为公平锁
ReentrantLock lock = new ReentrantLock(true);
使用要点：
- await 前需要获得锁
- await 执行后，会释放锁，进入 conditionObject 等待
- await 的线程被唤醒（或打断、或超时）取重新竞争 lock 锁
- 竞争 lock 锁成功后，从 await 后继续执
public class Code_32_Test {
public static void main(String[] args) {
WaitAndNotify waitAndNotify = new WaitAndNotify(1, 5);
new Thread(()->{
waitAndNotify.run("a", 1, 2);
}).start();
new Thread(()->{
waitAndNotify.run("b", 2, 3);
}).start();
new Thread(()->{
waitAndNotify.run("c", 3, 1);
}).start();
}
}
class WaitAndNotify {
public void run(String str, int flag, int nextFlag) {
for(int i = 0; i < loopNumber; i++) {
synchronized(this) {
while (flag != this.flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.print(str);
// 设置下一个运行的线程标记
this.flag = nextFlag;
// 唤醒所有线程
this.notifyAll();
}
}
}
private int flag;
private int loopNumber;
public WaitAndNotify(int flag, int loopNumber) {
this.flag = flag;
this.loopNumber = loopNumber;
}
}
public class Code_33_Test {
public static Thread t1, t2, t3;
public static void main(String[] args) {
ParkAndUnPark obj = new ParkAndUnPark(5);
t1 = new Thread(() -> {
obj.run("a", t2);
});
t2 = new Thread(() -> {
obj.run("b", t3);
});
t3 = new Thread(() -> {
obj.run("c", t1);
});
t1.start();
t2.start();
t3.start();
LockSupport.unpark(t1);
}
}
class ParkAndUnPark {
public void run(String str, Thread nextThread) {
for(int i = 0; i < loopNumber; i++) {
LockSupport.park();
System.out.print(str);
LockSupport.unpark(nextThread);
}
}
private int loopNumber;
public ParkAndUnPark(int loopNumber) {
this.loopNumber = loopNumber;
}
}
public class Code_34_Test {
public static void main(String[] args) {
AwaitAndSignal lock = new AwaitAndSignal(5);
Condition a = lock.newCondition();
Condition b = lock.newCondition();
Condition c = lock.newCondition();
new Thread(() -> {
lock.run("a", a, b);
}).start();
new Thread(() -> {
lock.run("b", b, c);
}).start();
new Thread(() -> {
lock.run("c", c, a);
}).start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.lock();
try {
a.signal();
}finally {
lock.unlock();
}
}
}
class AwaitAndSignal extends ReentrantLock {
public void run(String str, Condition current, Condition nextCondition) {
for(int i = 0; i < loopNumber; i++) {
lock();
try {
current.await();
System.out.print(str);
nextCondition.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
unlock();
}
}
}
private int loopNumber;
public AwaitAndSignal(int loopNumber) {
this.loopNumber = loopNumber;
}
}
本章我们需要重点掌握的是
应用方面
原理方面
模式方面