回顾一下多线程-贰

回顾一下多线程-贰
线程同步-synchronized
买票
银行取款
关于试错技巧
集合与线程安全
非线程同步
线程同步
线程安全集合
死锁
产生条件
解决方案
可重入锁-ReentrantLock
多线程与循环控制
延迟对多线程的影响
一
二
三
线程通信-wait-notify
线程池

线程同步-synchronized

多个线程操作同一资源时会有问题出现,用 synchronized 同步.
线程同步的形成条件: 队列+锁
实现形式有同步方法和同步代码块

同步方法, 锁的是方法所属对象 this
如下买票例子中 buy 方法锁的是 Ticket ticket 这个对象
public synchronized void buy() {}
同步代码块, 锁 obj
synchronized (obj) {
// 操作
}

买票

public class Ticket implements Runnable {
  private int ticketNums = 10; //票数
  boolean flag = true; //外部停止方法

  @Override
  public void run() {
    while (flag) {
      buy();
      //模拟延时
      try {
        Thread.sleep(200);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  public synchronized void buy() {
    //判断是否有票
    if (ticketNums <= 0) {
      flag = false;
      return;
    }
    System.out.println(Thread.currentThread().getName() + "-->得到倒数第" + ticketNums-- + "票");
  }

  public static void main(String[] args) {
    Ticket ticket = new Ticket();

    new Thread(ticket, "小明").start();
    new Thread(ticket, "老师").start();
    new Thread(ticket, "黄牛").start();
  }
}

结果

不加锁: 有错误

小明-->得到倒数第10票
老师-->得到倒数第9票
黄牛-->得到倒数第8票
老师-->得到倒数第7票
小明-->得到倒数第6票
黄牛-->得到倒数第5票
老师-->得到倒数第4票
小明-->得到倒数第3票
黄牛-->得到倒数第3票
老师-->得到倒数第2票
小明-->得到倒数第1票
黄牛-->得到倒数第1票

加锁: 无误

小明-->得到倒数第10票
黄牛-->得到倒数第9票
老师-->得到倒数第8票
小明-->得到倒数第7票
黄牛-->得到倒数第6票
老师-->得到倒数第5票
黄牛-->得到倒数第4票
小明-->得到倒数第3票
老师-->得到倒数第2票
黄牛-->得到倒数第1票

银行取款

import java.math.BigDecimal;

public class Bank {
  public static void main(String[] args) {
    Account account = new Account(new BigDecimal(100), "我的账户");

    DrawingChannel a = new DrawingChannel(account, new BigDecimal(50), "A");
    DrawingChannel b = new DrawingChannel(account, new BigDecimal(100), "B");

    a.start();
    b.start();
  }
}

//账户
class Account {
  BigDecimal balance;//余额
  final String name; //卡名

  public Account(BigDecimal balance, String name) {
    this.balance = balance;
    this.name = name;
  }
}

/**
 * 银行：模拟取款
 * * 这里之所以没用实现Runnable接口的方式是为了调用Thread类中一些方法
 */
class DrawingChannel extends Thread {
  final Account account; //账户
  BigDecimal drawingMoney; //取了多少钱
  BigDecimal nowMoney; //现在手里有多少钱

  public DrawingChannel(Account account, BigDecimal drawingMoney, String name) {
    super(name);
    this.account = account;
    this.drawingMoney = drawingMoney;
    this.nowMoney = new BigDecimal(0);
  }

  @Override
  public void run() {
    synchronized (account) {
      //判断有没有钱
      if (account.balance.compareTo(drawingMoney) < 0) {
        System.out.println(account.name + "钱不够" + drawingMoney + "," + this.getName() + "无法取走");
        return;
      }

      // 放大错误
      try {
        sleep(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      draw();
    }
  }

  private void draw() {
    //卡内余额 = 余额 - 取的钱
    account.balance = account.balance.subtract(drawingMoney);
    System.out.println(this.getName() + "取走" + drawingMoney);

    //手里的钱
    nowMoney = nowMoney.add(drawingMoney);

    System.out.println(account.name + "余额为：" + account.balance);
    System.out.println(this.getName() + "手里的钱：" + nowMoney);
  }
}

预期结果

A取走50
我的账户余额为：50
A手里的钱：50
我的账户钱不够100,B无法取走

关于试错技巧

熟练使用.sleep()试错

试错前

我的账户钱不够100,B无法取走
我的账户余额为：50
A手里的钱：50

试错后

B 取走 100
A 取走 50
我的账户余额为：50
我的账户余额为：50
A 手里的钱：50
B 手里的钱：100

集合与线程安全

多个线程同时操作集合对象时可能会存在覆写(线程不安全)

非线程同步

public class TestList {
  public static void main(String[] args) throws InterruptedException {
    List<String> list = new ArrayList<String>();

    for (int i = 0; i < 10000; i++) {
      new Thread(() -> {
        list.add(Thread.currentThread().getName());
      }).start();
    }
    Thread.sleep(3000); // 延时,为了等上面执行完毕
    System.out.println(list.size());//输出：9992
  }
}

线程同步

public class TestList {
  public static void main(String[] args) throws InterruptedException {
    List<String> list = new ArrayList<String>();

    for (int i = 0; i < 10000; i++) {
      new Thread(() -> {
        synchronized (list) {
          list.add(Thread.currentThread().getName());
        }
      }).start();
    }
    Thread.sleep(3000); // 延时,为了等上面执行完毕
    System.out.println(list.size());//输出：10000
  }
}

线程安全集合

public class JUC {
  public static void main(String[] args) throws InterruptedException {
    List<String> list = new CopyOnWriteArrayList<String>();

    for (int i = 0; i < 10000; i++) {
      new Thread(() -> {
        list.add(Thread.currentThread().getName());
      }).start();
    }

    Thread.sleep(3000);
    System.out.println(list.size());//输出：10000
  }
}

死锁

两线程在各自拥有一个对象的锁时都等待对方线程释放对象的锁 ; 也有可能很多线程产生环形/网状死锁.

如下例子就会产生死锁

//死锁：多个线程互相抱着对方需要的资源
public class DeadLock {
  public static void main(String[] args) {
    Makeup m1 = new Makeup(0, "小黑");
    Makeup m2 = new Makeup(1, "小白");

    m1.start();
    m2.start();
  }
}

//口红
class Lipstick {
}

//镜子
class Mirror {
}

//化妆
class Makeup extends Thread {
  //需要的资源只有一份，用static来保证只有一份
  static final Lipstick lipstick = new Lipstick();
  static final Mirror mirror = new Mirror();

  int choice; //选择
  String name; //使用化妆品的人

  public Makeup(int choice, String name) {
    this.choice = choice;
    this.name = name;
  }

  @Override
  public void run() {
    //化妆
    try {
      makeup();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }

  //化妆，互相持有对方的锁，就是需要拿到对方的资源
  private void makeup() throws InterruptedException {
    if (choice == 0) {
      synchronized (lipstick) { //获得口红的锁
        System.out.println(this.name + "获得口红的锁");
        Thread.sleep(1000);

        synchronized (mirror) { //一秒钟后想获得镜子的锁
          System.out.println(this.name + "获得镜子的锁");
        }
      }
    } else {
      synchronized (mirror) { //获得镜子的锁
        System.out.println(this.name + "获得镜子的锁");
        Thread.sleep(2000);
        synchronized (lipstick) { //两秒钟后想获得口红的锁
          System.out.println(this.name + "获得口红的锁");
        }
      }
    }
  }
}

产生条件

四个必要条件:
1. 互斥条件：一个资源每次只能被一个进程使用。
2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
3. 不剥夺条件：进程已获得的资源，在未使用完之前不能强行剥夺。
4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

解决方案

使用完同步对象后立即释放

比如上面的例子中使用完口红或者镜子后未释放,再去获取另一个对象的锁,就会产生死锁了
修改: 把 makeup 改为如下

private void makeup() throws InterruptedException {
  if (choice == 0) {
    synchronized (lipstick) { // 获得口红的锁
      System.out.println(this.name + "获得口红的锁");
      Thread.sleep(1000);
    }
    synchronized (mirror) { // 一秒钟后想获得镜子的锁
      System.out.println(this.name + "获得镜子的锁");
    }
  } else {
    synchronized (mirror) { // 获得镜子的锁
      System.out.println(this.name + "获得镜子的锁");
      Thread.sleep(2000);
    }
    synchronized (lipstick) { // 两秒钟后想获得口红的锁
      System.out.println(this.name + "获得口红的锁");
    }
  }
}

可重入锁-ReentrantLock

ReentrantLock (也叫 RT-Lock) 类实现了 java.util.concurrent.locks.Lock 接口
与 synchronized 区别:
1. ReentrantLock 是显式加解锁,它只能锁代码块
2. 性能比 synchronized 好
使用优先度: ReentrantLock > 同步代码块(已经进入了方法体，分配了相应资源) > 同步方法(在方法体之外)

注意点: 加解锁最好要在 try-finally 里

try {
while (true) {
  lock.lock();
  try {
    if ( ) {
      // ...
    } else {
      // ...
    }
  } catch (InterruptedException ignored) {
  } finally {
    lock.unlock();
  }
}

例子

public class TestLock implements Runnable {
  int ticketNums = 10;
  private final ReentrantLock lock = new ReentrantLock(); // 定义Lock锁

  @Override
  public void run() {
    while (true) {
      try {
        lock.lock(); // 加锁
        if (ticketNums > 0) {
          System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "票");
        } else {
          break;
        }
      } finally {
        lock.unlock(); // 解锁
        try {
          Thread.sleep(500);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }
  }

  public static void main(String[] args) {
    TestLock testLock = new TestLock();

    new Thread(testLock, "a").start();
    new Thread(testLock, "b").start();
    new Thread(testLock, "c").start();
  }
}

结果

a-->拿到了第10票
c-->拿到了第9票
b-->拿到了第8票
b-->拿到了第7票
c-->拿到了第6票
a-->拿到了第5票
b-->拿到了第4票
a-->拿到了第3票
c-->拿到了第2票
c-->拿到了第1票

多线程与循环控制

public class TestLock implements Runnable {
  int ticketNums = 10;
  private final ReentrantLock lock = new ReentrantLock(); // 定义Lock锁

  @Override
  public void run() {
    while (ticketNums > 0) {
      try {
        lock.lock(); // 加锁
        Thread.sleep(500);
        System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "票");
      } catch (InterruptedException e) {
        e.printStackTrace();
      } finally {
        lock.unlock(); // 解锁
      }
    }
  }

  public static void main(String[] args) {
    TestLock testLock = new TestLock();

    new Thread(testLock, "a").start();
    new Thread(testLock, "b").start();
    new Thread(testLock, "c").start();
  }
}

上面代码 while 循环会存在判断失误

c-->拿到了第10票
c-->拿到了第9票
c-->拿到了第8票
c-->拿到了第7票
c-->拿到了第6票
c-->拿到了第5票
c-->拿到了第4票
c-->拿到了第3票
c-->拿到了第2票
c-->拿到了第1票
b-->拿到了第0票
a-->拿到了第-1票

ticketNums 在判断之后被多次修改
上面 10~1 次都是 c 线程执行的,它执行后轮到 b 和 a
但是 b 与 a 线程实际上是在ticketNums=10时进入的循环,所以会导致-1出现
所以建议遇到多线程循环控制时,直接while(true),然后在内部用if
(反过来想: 是因为 lock 不能在循环之外加)

延迟对多线程的影响

下面三个例子数据都没错,关键看并发数量和执行时间

一

瞬间执行完,资源被单一线程全部抢占 (并非不合理,只不过是处理器没分配到 B,C)

public class TestLock implements Runnable {
  int ticketNums = 10;
  private final ReentrantLock lock = new ReentrantLock(); // 定义Lock锁

  @Override
  public void run() {
    while (true) {
      try {
        lock.lock(); // 加锁
        if (ticketNums > 0) {
          System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "票");
        } else {
          break;
        }
      } finally {
        lock.unlock(); // 解锁
        // try {
        //   Thread.sleep(500);
        // } catch (InterruptedException e) {
        //   e.printStackTrace();
        // }
      }
    }
  }

  public static void main(String[] args) {
    TestLock testLock = new TestLock();

    new Thread(testLock, "a").start();
    new Thread(testLock, "b").start();
    new Thread(testLock, "c").start();
  }
}

c-->拿到了第9票
c-->拿到了第8票
c-->拿到了第7票
c-->拿到了第6票
c-->拿到了第5票
c-->拿到了第4票
c-->拿到了第3票
c-->拿到了第2票
c-->拿到了第1票

二

给他加个延迟试试: 三线程并行,资源分配合理

public void run() {
  while (true) {
    try {
      lock.lock(); // 加锁
      if (ticketNums > 0) {
        System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "票");
      } else {
        break;
      }
    } finally {
      lock.unlock(); // 解锁
      try {
        Thread.sleep(500);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}

b-->拿到了第10票
a-->拿到了第9票
c-->拿到了第8票
b-->拿到了第7票
a-->拿到了第6票
c-->拿到了第5票
c-->拿到了第4票
a-->拿到了第3票
b-->拿到了第2票
b-->拿到了第1票

三

再试试延迟之后解开同步锁: 单线执行,资源分配不平衡

public void run() {
  while (true) {
    try {
      lock.lock(); // 加锁
      if (ticketNums > 0) {
        System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "票");
      } else {
        break;
      }
    } finally {
      try {
        Thread.sleep(500);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      lock.unlock(); // 解锁
    }
  }
}

a-->拿到了第10票
a-->拿到了第9票
c-->拿到了第8票
c-->拿到了第7票
c-->拿到了第6票
c-->拿到了第5票
c-->拿到了第4票
c-->拿到了第3票
c-->拿到了第2票
b-->拿到了第1票

线程通信-wait-notify

class Clerk {
  public int productNumber; // 售货员手中的商品数
}

public class ProducterAndCustomer {
  public static void main(String[] args) {
    Clerk clerk = new Clerk();

    new Thread(() -> {
      while (true) { //一直生产
        synchronized (clerk) {
          try {
            if (clerk.productNumber == 0) {
              System.out.println("产品为0, 开始生产");
              while (clerk.productNumber < 5) {
                System.out.println("库存: " + clerk.productNumber++);
                Thread.sleep(500);
              }
              clerk.notifyAll();
              //商品数不为0时让clerk等待
            } else {
              // clerk.wait();
              clerk.wait();
            }
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      }
    }, "生产者").start();

    new Thread(() -> {
      while (true) { //一直消费
        synchronized (clerk) {
          try {
            if (clerk.productNumber == 5) {
              System.out.println("产品为5,开始消费");
              while (clerk.productNumber > 0) {
                System.out.println("库存: " + clerk.productNumber--);
                try {
                  Thread.sleep(500);
                } catch (InterruptedException e) {
                  e.printStackTrace();
                }
              }
              clerk.notifyAll();
            } else {
              // clerk.wait();
              clerk.wait();
            }
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      }
    }, "消费者").start();
  }
}

结果

产品为0, 开始生产
库存: 0
库存: 1
库存: 2
库存: 3
库存: 4
产品为5,开始消费
库存: 5
库存: 4
库存: 3
库存: 2
库存: 1
产品为0, 开始生产
库存: 0

线程池

线程池的出现是为了方便大量的线程创建,回收和管理
需要了解 ExecutorService 线程池接口;以及 Executors 线程池工具类.
- corePoolSize: 核心池的大小
- maximumPoolSize:最大线程数
- keepAliveTime: 线程没有任务时最多保持多长时间后会终止
- void execute(Runnable command) :执行任务/命令,没有返回值，一般用来执 Runnable
- Futuresubmit(Callabletask) :执行任务,有返回值，一般用来执行 Callable

例子

public class TestThreadPool {
  public static void main(String[] args) throws ExecutionException, InterruptedException {
    // 1.创建服务，创建线程池
    ExecutorService service = Executors.newFixedThreadPool(10);
    Runnable runnable = () -> {
      System.out.println(Thread.currentThread().getName() + " runnable");
    };
    Callable<String> callable = () -> {
      return Thread.currentThread().getName() + " callable";
    };

    // 2. 执行
    for (int i = 0; i < 5; i++) {
      service.execute(runnable);
      System.out.println(service.submit(callable).get());
    }

    // 3.关闭连接
    service.shutdown();
  }
}
/*
  pool-1-thread-1 runnable
  pool-1-thread-2 callable
  pool-1-thread-3 runnable
  pool-1-thread-4 callable
  pool-1-thread-5 runnable
  pool-1-thread-6 callable
  pool-1-thread-7 runnable
  pool-1-thread-8 callable
  pool-1-thread-9 runnable
  pool-1-thread-10 callable
*/

🌭回顾一下多线程-贰

回顾一下多线程-贰

线程同步-synchronized

买票

银行取款

关于试错技巧

集合与线程安全

非线程同步

线程同步

线程安全集合

死锁

产生条件

解决方案

可重入锁-ReentrantLock

多线程与循环控制

延迟对多线程的影响

一

二

三

线程通信-wait-notify

线程池

-> 欢迎,锟斤拷! <-

低情商：代码一坨屎
高情商：兼容性极强

回顾一下多线程-贰

线程同步-synchronized

买票

银行取款

关于试错技巧

集合与线程安全

非线程同步

线程同步

线程安全集合

死锁

产生条件

解决方案

可重入锁-ReentrantLock

多线程与循环控制

延迟对多线程的影响

一

二

三

线程通信-wait-notify

线程池

-> 欢迎,锟斤拷! <-

低情商：代码一坨屎高情商：兼容性极强

低情商：代码一坨屎
高情商：兼容性极强