Java基础（十九）——
一、线程安全（同步锁和监视器）
1、引子——线程不安全
举个例子引入安全锁：
10家店，同时卖1000部电脑。换成代码就是10条线程，争抢一个资源（代码如下）：
这样会造成一个很严重的问题，就是会出现多个线程同时争抢一个资源，且存在多个线程同时抢到这个资源：
这种现象就是线程不安全。
2、线程安全问题
线程安全问题：多个线程同时访问异步临界资源，可能会造成数据混乱。
异步：大家一起访问。
解决方法：
1、同步锁：synchronized
1.1 同步代码块：
需要同步的代码放在同步代码块中，添加同步锁和同步监视器要求多个线程访问的时候，使用的是同一个对象的同
步监视器当有线程进入同代码块，其他线程则会等待进入同步代码块的线程执行完毕后才会进入。
1.2 同步方法:
被同步锁修饰的方法为同步方法，同步监视器为方法本身当一条线程调用同步方法时，其他线程则会等待同步方法
执行完再调用，要求方法为静态方法或者使用同一个对象
3、同步锁（同步代码块）解决线程安全
同步代码块：
synchronized ( 这里需要放入同步监视器 ) {
}
之所以要放入同步监视器，是因为这里创建了 10 条线程，每条都是独立的。如果访问的不是同一个对象，各自访问不同的对象，那就毫无意义，实现不了同步。只有所有线程都访问同一个资源，才能实现同步。
一般会定义一个临界资源，充当同步监视器：
注意：这个同步监视器必须为对象，如果是静态常量也不行。
最终代码：
public class Homework {
public static void main(String[] args) {
ExecutorService loop = Executors.newFixedThreadPool(10); // 在线程池开10条线程
Sell sell = new Sell();
for (int i = 1; i < 11; i++) {
loop.submit(sell);
}
loop.shutdown();
}
}
class Sell implements Runnable{
static int num = 1; // 独享一份空间
static final Object obj = new Object();
@Override
public void run() {
while (num < 1001){
// synchronized 这个是同步锁。 obj 这个是监视器
synchronized (obj){
if (num < 1001){
System.out.println("第"+(Thread.currentThread().getId()-10)+"家外星人店出售第"+num+"台电脑");
}
num++;
}
}
System.out.println("第"+(Thread.currentThread().getId()-10)+"家外星人店已售罄");
}
}
注意：锁要放在 if 判断语句的外面。如果放在里面，会出现溢出现象。因为会存在同时有几条线程进来，其中一条线程已经到1000了，而后面排队的线程会继续取资源，接着出现1001这种现象（最多不会超过1000 + 线程数量）。
经测试可知：最终效果实现了，没有出现线程安全问题。
4、同步锁（同步方法）解决线程安全
a、继承方式
只需要在方法返回值前面加个 synchronized ，即是同步方法。不过要注意的是，不能直接加到 run 方法里面，需要另外开个方法。不过此时还不够，因为缺少同步监视器。同步方法监视器就是同步方法本身。 且必须保证每个线程调用的都是同一个方法，所以这个方法是要静态的，才能发挥同步监视器的作用。
代码：
public class Demo01 {
public static void main(String[] args) {
for (int i = 1; i < 11; i++) { // 开启10条线程
new MyThread("第"+i+"家").start();
}
}
}
class MyThread extends Thread{
static int computer = 1;
private boolean flag = true; // 开关。控制循环是否继续。
public MyThread(String name){ // 调用父类有参构造方法，给线程新的名字。因为线程本身能够调用 getName（）方法。
super(name);
}
@Override
public void run() { // 重写 run 方法
while (flag){ // while 循环不能加在同步方法里面。
flag = sell();
}
}
// 同步方法的监视器为方法本身，且方法为静态的
public synchronized static boolean sell(){
if (computer<1001){
System.out.println(Thread.currentThread().getName()+"外星人专卖店卖出第"+computer+"台电脑");
computer++;
return true;
}else {
System.out.println(Thread.currentThread().getName()+"外星人专卖店已售罄");
return false;
}
}
b、实现方式
上面是通过继承的方式实现的。如果是实现接口的方式，下面这个地方要改：
这里可以有两个参数。
图解：
5、回顾 StringBuffer 和 StringBuilder
这两个以前提到过，看其底层代码可知哪个线程安全：
结论是：StringBuffer 安全。
二、让线程陷入阻塞的方法
1、了解wait（）
前面学过，让线程陷入阻塞的有 sleep（），是通过 Thread 直接调用的。 wait（）也能让线程陷入阻塞，通过对象调用。wait（）来自 Object 类。
2、wait 和 sleep 在同步代码块内的不同表现
测试，wait 和 sleep 在同步代码块中的不同表现。如果线程陷入阻塞了，其他线程还能进来，说明该线程的资源被释放了；反之，如果不能进来，说明该线程的资源没有被释放，其他线程还在等待。
a、sleep 在同步区域内休眠
测试代码：
class MyThread extends Thread{ // 测试休眠是否会释放资源
public void run(){
synchronized (Demo01.obj){
System.out.println(Thread.currentThread().getName()+"线程A开始休眠");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"线程A结束休眠");
}
}
}
b、wait 在同步区域内等待
class MyThread2 extends Thread{ // 测试等待是否会释放资源
public void run(){
synchronized (Demo01.obj){
System.out.println(Thread.currentThread().getName()+"线程Z开始等待");
try {
Demo01.obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"线程Z结束等待");
}
}
}
结果：
可以看到，其他线程进来了。
c、结论——同步区域内
经测试得出结论：
线程在同步区域内进入 休眠 状态，线程不会释放资源。
线程在同步区域内进入 等待 状态，线程会释放资源。
d、wait（）必须通过同步监视器的对象进行调用
这里可以看到，都是同一个对象。如果换一个对象，也同样是静态常量，就会报错：
然后运行结果：
报错了。
3、wait 和 sleep 在同步区域外中的不同表现
a、sleep
在同步区域外是否可以休眠。
以往使用 sleep 的时候，就没有同步区域，那时候也没有报错。
b、wait
可以看到，报错了。
c、结论
wait 只能在同步区域中使用。
4、不同对象无法在同步中使用 wait（）
准确点说：同一个对象的同步方法里面使用当前对象调用。
这里直接说能够实现的方法：
通过实现接口的方式实现线程，然后通过 this 的方式去调用 wait（）方法，才能成功调用，其他方式都不行。
代码：
class MyThread2 implements Runnable{ // 通过实现接口的方式。继承方式不行
@Override
public void run(){
method();
}
private synchronized void method() { // 这里没有 static
System.out.println(Thread.currentThread().getName()+"开始等待");
try {
this.wait(); // 这里只能用 this 。如果是通过类直接调用同步监视器，不行。
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"结束等待");
}
}
5、sleep 和 wait 的各自唤醒方法
直接上结论：
sleep ：顾名思义，休眠一段时间会自己唤醒。所以 sleep 会自动唤醒。
wait ： 需要 notify（） 或者 notifyAll（） 来唤醒。其中， notifyAll（）是唤醒全部线程；而 notify 是华唤醒一条线程。
a、唤醒一条线程
结果：
b、唤醒全部线程
三、lock——手动上锁（互斥锁/可重入锁）
1、初识 lock
先看下有什么方法：
2、lock 的使用
需要实例化对象：
然后给需要上锁的代码块上锁：
这样，设置好代码以后，就能实现同步的效果。
同样是用卖外星人电脑举例子。这里采用继承的方式创建线程：
public class Demo01 {
public static void main(String[] args) {
for (int i = 1; i < 11; i++) { // 开启10条线程
new MyThread("第"+i+"家").start();
}
}
}
class MyThread extends Thread{
static int computer = 1;
private static ReentrantLock lock = new ReentrantLock(); // 如果通过线程的方式创建线程，为了保证每一条线程用的都是同一个锁，这里需要加 static
public MyThread(String name){ // 调用父类有参构造方法，给线程新的名字。因为线程本身能够调用 getName（）方法
super(name);
}
@Override
public void run() { // 重写 run 方法
while (true){
lock.lock(); // 手动上锁
try {
if (computer<1001){
System.out.println(Thread.currentThread().getName()+"外星人专卖店卖出第"+computer+"台电脑");
computer++;
}else {
System.out.println(Thread.currentThread().getName()+"外星人专卖店已售罄");
break;
}
}finally {
lock.unlock(); // 既然最终都要执行这个解锁，就放到 finally 里面
}
}
}
四、公平锁
1、了解公平锁和非公平锁
这里需要解释下公平锁和非公平锁的概念：
公平：每条线程轮流拿取资源，每条线程都有份，就是公平锁。
非公平：可能存在一条线程拿取多个资源，就是非公平锁。非公平锁的线程拿取资源是随机的
下图这种就是不公平的：
电脑都被第二家店铺垄断了。
2、公平锁的创建方式
公平锁的创建方式很简单：
只需要在创建 lock 的时候，里面传递 true 这个参数，就是公平锁了。
3、对公平锁的误解
有时候创建了公平锁，10条线程，但是拿取资源的时候并不是每个资源都轮流拿，这是怎么回事呢？
首先，这里确实是公平锁了。不能出现每条线程轮流拿取资源是因为有的线程太快了，在其他线程还没创建的时候，就立马又回来拿资源。可以手动增加线程的工作时间，跳到一个适当的空隙，就能看到每条线程轮流拿取资源。但要承认的事实是，确实这里已经是公平锁。
举个例子：几个人轮流买奶茶，第一个人买完奶茶走了，但是第二个人离奶茶店还有点距离，第一个人买完就立马转身回来买第二杯奶茶。如果增加第一个人买完奶茶后回奶茶店买奶茶的距离，就能看到轮流买奶茶的景象。就是这个道理。