第3 章 ： 线程的同步与死锁
14 同步问题引出
Thread描述每一个线程对象
Runnable描述多个线程操作的资源
多个线程访问同一资源的时候，如果处理不当会产生数据错误
3个线程卖票程序，会出现多张同号的票
class MyThread implements Runnable { private int ticket = 10; @Override public void run() { while (true) { if (this.ticket > 0) { System.out.println( Thread.currentThread().getName() + "卖第" + this.ticket + " 张票" ); this.ticket--; } else { System.out.println("票卖光了"); break; } } } } public class Demo { public static void main(String[] args) { MyThread thread = new MyThread(); new Thread(thread).start(); new Thread(thread).start(); new Thread(thread).start(); // 5 } }
15 线程同步处理
同步：多个操作在同一时间段内只能有一个线程进行，
其他线程要等待此线程完成之后才可以继续还行
解决同步问题的方式是锁
synchronized定义同步方法或同步代码块，里边的代码只允许一个线程执行
加入同步之后，程序整体性能下降了
1、同步代码块
synchronized(同步对象){}
举例
synchronized (this) { if (this.ticket > 0) { System.out.println(Thread.currentThread().getName() + "卖第" + this.ticket + " 张票"); this.ticket--; } else { System.out.println("票卖光了"); break; } }
2、同步函数
public synchronized boolean method(){}
举例
public synchronized boolean sale(){ if (this.ticket > 0) { System.out.println(Thread.currentThread().getName() + "卖第" + this.ticket + " 张票"); this.ticket--; return true; } else { System.out.println("票卖光了"); return false; } }
16 线程死锁
死锁是在进行多线程同步处理之中有可能产生的一种问题
是指若干个线程彼此互相等待的状态
若干线程访问同一资源时，一定要进行同步处理
而过多的同步会造成死锁
public class Demo { public static void main(String[] args) { //o1 o2 代表资源 Object o1 = new Object(); Object o2 = new Object(); System.out.println("go go go!"); Thread t1 = new Thread(new Runnable() { public void run() { synchronized (o1) { //线程t1获取o1的锁才能继续执行 try { Thread.sleep(3000); //睡3秒，确保线程t2把o2锁拿走 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("t1获得了哦O1"); synchronized (o2) { //线程t1获取o2的锁才能继续执行 System.out.println("t1获得了哦O2"); } } } }); Thread t2 = new Thread(new Runnable() { public void run() { synchronized (o2) { //线程t2获取o2的锁才能继续执行 try { Thread.sleep(3000); //睡3秒，确保线程t1把o1锁拿走 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("t2获得了哦O2"); synchronized (o1) { //线程t2获取o1的锁才能继续执行 System.out.println("t2获得了哦O1"); } } } }); t1.start(); t2.start(); //启动线程 } }
第4 章 ： 综合实战：“生产者-消费者”模型
17 生产者与消费者基本程序模型
生产者负责信息内容生产
消费者取走信息
消费者要等待生产者生产完成再取走
生产者需要等待消费者消费完成再生产
不加锁示例
class Message { private String content; public void setContent(String content) { this.content = content; } public String getContent() { return content; } } class Producer implements Runnable { private Message message; private static int count; public Producer(Message message) { this.message = message; } @Override public void run() { for (int i = 0; i < 10; i++) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } this.message.setContent("这是第" + count + " 个消息"); count++; } } } class Consumer implements Runnable { private Message message; public Consumer(Message message) { this.message = message; } @Override public void run() { for (int i = 0; i < 10; i++) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(this.message.getContent()); } } } class Demo { public static void main(String[] args) { Message message = new Message(); new Thread(new Producer(message)).start(); new Thread(new Consumer(message)).start(); } } /** 这是第0 个消息 这是第0 个消息 这是第1 个消息 这是第2 个消息 这是第3 个消息 这是第4 个消息 这是第5 个消息 这是第6 个消息 这是第7 个消息 这是第8 个消息 */
18 解决生产者-消费者同步问题
增加关键字 synchronized
19 利用Object类解决重复操作
等待机制
(1)一直等待
public final void wait()
(2)等待一段时间
public final native void wait(long timeout)
唤醒线程
(1)唤醒一个等待线程, 唤醒第一个等待的线程
public final native void notify();
(2)唤醒全部等待线程,谁优先级高谁先执行
public final native void notifyAll();
完整代码
class Message { private String content; private boolean flag = false; // 生产完成就为true public synchronized void setContent(String content) { if (this.flag == true) { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } this.content = content; this.flag = true; notify(); } public synchronized String getContent() { if (this.flag == false) { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } try { return content; } finally { this.flag = false; notify(); } } } class Producer implements Runnable { private Message message; private static int count; public Producer(Message message) { this.message = message; } @Override public void run() { for (int i = 0; i < 10; i++) { this.message.setContent("这是第" + count + " 个消息"); count++; } } } class Consumer implements Runnable { private Message message; public Consumer(Message message) { this.message = message; } @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println(this.message.getContent()); } } } class Demo { public static void main(String[] args) { Message message = new Message(); new Thread(new Producer(message)).start(); new Thread(new Consumer(message)).start(); } }
第5 章 ： 多线程深入话题
20 优雅的停止线程
已废除的方法，可能会导致线程死锁，不建议使用
// 停止线程 public final void stop() // 销毁线程 public void destroy() // 挂起线程 public final void suspend() // 恢复线程 public final void resume()
使用flag 标志位不会立刻停止，而是当前线程自己判断
class Demo{ private static boolean flag = true; public static void main(String[] args) { new Thread(()->{ while (flag){ try { Thread.sleep(600); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"正在执行"); } }, "自定义线程").start(); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("时间到"); flag = false; } }
21 后台守护线程
守护线程，如果主线程退出，守护线程就退出
GC就是守护线程
设置为守护线程
public final void setDaemon(boolean on)
判断是否为守护线程
public final boolean isDaemon()
示例
设置线程为守护线程后，主程序执行完毕就退出了，并不会打印任何内容
class MyThread implements Runnable{ @Override public void run() { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+" 正在执行"); } } class Demo{ public static void main(String[] args) { Thread t = new Thread(new MyThread()); t.setDaemon(true); t.start(); } }
22 volatile关键字
volatile 用于属性定义， 中文意思：易变的
变量处理的步骤：
（1）获取变量原有的数据内容副本
（2）利用副本为变量进行数学计算
（3）建计算后的变量，保存到原始空间中
读取read <- 数据副本 加载load 使用use 赋值asign 存储store 写入write -> 原始空间
属性上加了volatile, 没有中间拷贝过程，直接使用原始数据
区别：volatile 和 synchronized
volatile： 主要在属性上使用，无法描述同步，直接内存处理，避免副本操作
synchronized： 代码块与方法上使用
class MyThread implements Runnable{ private volatile int count = 10; @Override public void run() { while (count>0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+" 正在执行"); count --; } } } class Demo{ public static void main(String[] args) { Thread t = new Thread(new MyThread()); t.start(); } }
