一，线程的所有状态 ( Thread.State )
* Thread.State 是一个枚举类型
1，NEW: 安排了工作, 还未开始行动
2，RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.
3， BLOCKED: 这几个都表示排队等着其他事情
4，WAITING: 这几个都表示排队等着其他事情
5，TIMED_WAITING: 这几个都表示排队等着其他事情
6，TERMINATED: 工作完成了.
二，线程安全
举个栗子：
static class Counter {
public int count=0;
void increase() {
count++;
}
}
public static void main(String[] args) throws InterruptedException {
final Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 50000; i++) {
counter.increase();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 50000; i++) {
counter.increase();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(counter.count);
}
* 这个代码并不能得出100000的结果，那么为什么会有这种现象呢？
2.1，线程安全的概念
我们可以这样认为：
如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的。
2.2，线程不安全的原因
1，修改共享数据
上面的线程不安全的代码中, 涉及到多个线程针对counter.count变量进行修改.
此时这个counter.count是一个多个线程都能访问到的 "共享数据"
counter.count这个变量就是在堆上. 因此可以被多个线程共享访问.
2，原子性
什么是原子性？
如果一个线程正在对一个变量操作，中途其他线程插入进来，打断了这个操作，那么就是不具备原子性。
那我们应该如何解决这个问题呢？是不是只要给线程加一把锁，将先进行操作的线程锁上，其他线程是不是就进不来了。这样就保证了这段代码的原子性了。
有时也把这个现象叫做同步互斥，表示操作是互相排斥的。
* 一条 java 语句不一定是原子的，也不一定只是一条指令
如刚才我们看到的 n++，其实是由三步操作组成的：
1. 从内存把数据读到 CPU
2.进行数据更新
3.把数据写回到CPU
3，可见性
可见性指，一个线程对共享变量值的修改能够及时的被其他线程看见
4，代码顺序性
什么是代码重排序
一段代码是这样的：
1.在食堂吃午餐
2.回宿舍睡觉
3.在食堂买瓶水
如果是在单线程情况下，JVM、CPU指令集会对其进行优化，比如，按 1->3->2的方式执行，也是没问题，可以少跑一次食堂。这种叫做指令重排序。
编译器对于指令重排序的前提是 "保持逻辑不发生变化". 这一点在单线程环境下比较容易判断, 但是在多线程环境下就没那么容易了, 多线程的代码执行复杂程度更高, 编译器很难在编译阶段对代码的执行效果进行预测, 因此激进的重排序很容易导致优化后的逻辑和之前不等价.
* 重排序是一个比较复杂的话题, 涉及到 CPU 以及编译器的一些底层工作原理, 此处不做过多讨论
利用 ‘ 锁 ’ 解决 之前线程不安全问题
static class Counter {
public int count=0;
//利用 synchronized 上锁
synchronized void increase() {
count++;
}
}
public static void main(String[] args) throws InterruptedException {
final Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 50000; i++) {
counter.increase();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 50000; i++) {
counter.increase();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(counter.count);
}
三，synchronized 关键字
3.1 ，synchronized 的特性
1）互斥
synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到同一个对象 synchronized 就会阻塞等待.
* 进入 synchronized 修饰的代码块, 相当于加锁
* 退出 synchronized 修饰的代码块, 相当于解锁
可以粗略理解成, 每个对象在内存中存储的时候, 都存有一块内存表示当前的 "锁定" 状态(类似于房间的 "有人/无人").
如果当前是 "无人" 状态, 那么就可以使用, 使用时需要设为 "有人" 状态.
如果当前是 "有人" 状态, 那么其他人无法使用, 只能排队
阻塞等待
针对每一把锁, 操作系统内部都维护了一个等待队列. 当这个锁被某个线程占有的时候, 其他线程尝试进行加锁, 就加不上了, 就会阻塞等待, 一直等到之前的线程解锁之后, 由操作系统唤醒一个新的线程, 再来获取到这个锁.
注意：
1，上一个线程解锁之后, 下一个线程并不是立即就能获取到锁. 而是要靠操作系统来 "唤醒". 这也就是操作系统线程调度的一部分工作.
2，假设有 A B C 三个线程, 线程 A 先获取到锁, 然后 B 尝试获取锁, 然后 C 再尝试获取锁, 此时 B 和 C 都在阻塞队列中排队等待. 但是当 A 释放锁之后, 虽然 B 比 C 先来的, 但是 B 不一定就能获取到锁, 而是和 C 重新竞争, 并不遵守先来后到的规则. ( 不公平锁 )
2）刷新内存
synchronized 的工作过程：
1. 获得互斥锁
2. 从主内存拷贝变量的最新副本到工作的内存
3. 执行代码
4. 将更改后的共享变量的值刷新到主内存
5. 释放互斥锁
所以 synchronized 也能保证内存可见性
3）可重入
理解 "把自己锁死"
一个线程没有释放锁, 然后又尝试再次加锁。
synchronized 同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题；
在可重入锁的内部, 包含了 "线程持有者" 和 "计数器" 两个信息.
* 如果某个线程加锁的时候, 发现锁已经被人占用, 但是恰好占用的正是自己, 那么仍然可以继续获取到锁, 并让计数器自增.
* 解锁的时候计数器递减为 0 的时候, 才真正释放锁. (才能被别的线程获取到)
3.2 synchronized 使用示例
synchronized 本质上要修改指定对象的 "对象头". 从使用角度来看, synchronized 也势必要搭配一个具体的对象来使用.
1) 直接修饰普通方法:
锁的 SynchronizedDemo 对象
public class SynchronizedDemo {
public synchronized void methond() {
}
}2) 修饰静态方法:
锁的 SynchronizedDemo 类的对象
public class SynchronizedDemo {
public synchronized static void method() {
}
}3) 修饰代码块: 明确指定锁哪个对象.
锁当前对象
public class SynchronizedDemo {
public void method() {
synchronized (this) {
}
}
}锁类对象
public class SynchronizedDemo {
public void method() {
synchronized (SynchronizedDemo.class) {
}
}
}
* 两个线程竞争同一把锁, 才会产生阻塞等待. 两个线程分别尝试获取两把不同的锁, 不会产生竞争.
109
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
