主要内容
- 线程安全
- 线程死锁
- 线程的状态
- 线程间通讯
- 线程池
1 线程安全
1.1 线程安全产生的原因
- 多个线程在对共享数据进行读改写的时候，可能导致的数据错乱就是线程的安全问题了
package com.itheima.ticket_demo; /* 电影院 */ public class Ticket implements Runnable { private int ticketCount = 100; // 一共有一百张票 @Override public void run() { while (true) { // 如果票的数量为0 , 那么停止买票 if (ticketCount == 0) { break; } else { // 有剩余的票 , 开始卖票 ticketCount--; System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张"); } } } }
package com.itheima.ticket_demo; /* 1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100; 2 在Ticket类中重写run()方法实现卖票，代码步骤如下 A：判断票数大于0，就卖票，并告知是哪个窗口卖的 B：票数要减1 C：卖光之后，线程停止 3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下 A：创建Ticket类的对象 B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称 C：启动线程 */ public class TicketDemo { public static void main(String[] args) { // 创建任务类对象 Ticket ticket = new Ticket(); // 创建三个线程类对象 Thread t1 = new Thread(ticket); Thread t2 = new Thread(ticket); Thread t3 = new Thread(ticket); // 给三个线程命名 t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); // 开启三个线程 t1.start(); t2.start(); t3.start(); } }
注意 : 以上代码是有问题 , 接下来继续改进
- 因为出票是有时间的 , 所有现在在每次买票之前, 休眠100毫秒 , 尝试执行代码
package com.itheima.ticket_demo; /* 电影院 */ public class Ticket implements Runnable { private int ticketCount = 100; // 一共有一百张票 @Override public void run() { while (true) { // 如果票的数量为0 , 那么停止买票 if (ticketCount <= 0) { break; } else { // 模拟出票的时间 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } // 有剩余的票 , 开始卖票 ticketCount--; System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张"); } } } }
package com.itheima.ticket_demo; /* 1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100; 2 在Ticket类中重写run()方法实现卖票，代码步骤如下 A：判断票数大于0，就卖票，并告知是哪个窗口卖的 B：票数要减1 C：卖光之后，线程停止 3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下 A：创建Ticket类的对象 B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称 C：启动线程 */ public class TicketDemo { public static void main(String[] args) { // 创建任务类对象 Ticket ticket = new Ticket(); // 创建三个线程类对象 Thread t1 = new Thread(ticket); Thread t2 = new Thread(ticket); Thread t3 = new Thread(ticket); // 给三个线程命名 t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); // 开启三个线程 t1.start(); t2.start(); t3.start(); } }
- 通过上述代码的执行结果 , 发现了出现了负号票 , 和相同的票 , 数据有问题
- 问题出现的原因 : 多个线程在对共享数据进行读改写的时候，可能导致的数据错乱就是线程的安全问题了
1.2 线程的同步
- 概述 : java允许多线程并发执行，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证该变量的唯一性和准确性
- 分类
- 同步代码块
- 同步方法
- 锁机制。Lock
1.3 同步代码块
同步代码块 : 锁住多条语句操作共享数据，可以使用同步代码块实现 第一部分 : 格式 synchronized(任意对象) { 多条语句操作共享数据的代码 } 第二部分 : 注意 1 默认情况锁是打开的，只要有一个线程进去执行代码了，锁就会关闭 2 当线程执行完出来了，锁才会自动打开 第三部分 : 同步的好处和弊端 好处 : 解决了多线程的数据安全问题 弊端 : 当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
public class Ticket implements Runnable { private int ticketCount = 100; // 一共有一百张票 @Override public void run() { while (true) { synchronized (Ticket.class) { // 如果票的数量为0 , 那么停止买票 if (ticketCount <= 0) { break; } else { // 模拟出票的时间 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } // 有剩余的票 , 开始卖票 ticketCount--; System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张"); } } } } }
package com.itheima.synchronized_demo1; /* 1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100; 2 在Ticket类中重写run()方法实现卖票，代码步骤如下 A：判断票数大于0，就卖票，并告知是哪个窗口卖的 B：票数要减1 C：卖光之后，线程停止 3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下 A：创建Ticket类的对象 B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称 C：启动线程 */ public class TicketDemo { public static void main(String[] args) { // 创建任务类对象 Ticket ticket = new Ticket(); // 创建三个线程类对象 Thread t1 = new Thread(ticket); Thread t2 = new Thread(ticket); Thread t3 = new Thread(ticket); // 给三个线程命名 t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); // 开启三个线程 t1.start(); t2.start(); t3.start(); } }
1.4 同步方法
同步方法：就是把synchronized关键字加到方法上 格式：修饰符 synchronized 返回值类型 方法名(方法参数) { } 同步代码块和同步方法的区别: 1 同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码 2 同步代码块可以指定锁对象,同步方法不能指定锁对象 注意 : 同步方法时不能指定锁对象的 , 但是有默认存在的锁对象的。 1 对于非static方法,同步锁就是this。 2 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。 Class类型的对象
package com.itheima.synchronized_demo2; /* 同步方法：就是把synchronized关键字加到方法上 格式：修饰符 synchronized 返回值类型 方法名(方法参数) { } 同步代码块和同步方法的区别: 1 同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码 2 同步代码块可以指定锁对象,同步方法不能指定锁对象 注意 : 同步方法时不能指定锁对象的 , 但是有默认存在的锁对象的。 1 对于非static方法,同步锁就是this。 2 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。 Class类型的对象 */ public class Ticket implements Runnable { private int ticketCount = 100; // 一共有一百张票 @Override public void run() { while (true) { if (method()) { break; } } } private synchronized boolean method() { // 如果票的数量为0 , 那么停止买票 if (ticketCount <= 0) { return true; } else { // 模拟出票的时间 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } // 有剩余的票 , 开始卖票 ticketCount--; System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张"); return false; } } }
package com.itheima.synchronized_demo2; /* 1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100; 2 在Ticket类中重写run()方法实现卖票，代码步骤如下 A：判断票数大于0，就卖票，并告知是哪个窗口卖的 B：票数要减1 C：卖光之后，线程停止 3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下 A：创建Ticket类的对象 B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称 C：启动线程 */ public class TicketDemo { public static void main(String[] args) { // 创建任务类对象 Ticket ticket = new Ticket(); // 创建三个线程类对象 Thread t1 = new Thread(ticket); Thread t2 = new Thread(ticket); Thread t3 = new Thread(ticket); // 给三个线程命名 t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); // 开启三个线程 t1.start(); t2.start(); t3.start(); } }
1.5 Lock锁
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁， 为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock Lock中提供了获得锁和释放锁的方法 void lock()：获得锁 void unlock()：释放锁 Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化 ReentrantLock的构造方法 ReentrantLock()：创建一个ReentrantLock的实例 注意：多个线程使用相同的Lock锁对象，需要多线程操作数据的代码放在lock()和unLock()方法之间。一定要确保unlock最后能够调用
package com.itheima.synchronized_demo3; import java.util.concurrent.locks.ReentrantLock; /* 虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁， 为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock Lock中提供了获得锁和释放锁的方法 void lock()：获得锁 void unlock()：释放锁 Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化 ReentrantLock的构造方法 ReentrantLock()：创建一个ReentrantLock的实例 注意：多个线程使用相同的Lock锁对象，需要多线程操作数据的代码放在lock()和unLock()方法之间。一定要确保unlock最后能够调用 */ public class Ticket implements Runnable { private int ticketCount = 100; // 一共有一百张票 ReentrantLock lock = new ReentrantLock(); @Override public void run() { while (true) { try { lock.lock();// 加锁 // 如果票的数量为0 , 那么停止买票 if (ticketCount <= 0) { break; } else { // 模拟出票的时间 Thread.sleep(100); // 有剩余的票 , 开始卖票 ticketCount--; System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张"); } } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock();// 释放锁 } } } }
package com.itheima.synchronized_demo3; /* 1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100; 2 在Ticket类中重写run()方法实现卖票，代码步骤如下 A：判断票数大于0，就卖票，并告知是哪个窗口卖的 B：票数要减1 C：卖光之后，线程停止 3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下 A：创建Ticket类的对象 B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称 C：启动线程 */ public class TicketDemo { public static void main(String[] args) { // 创建任务类对象 Ticket ticket = new Ticket(); // 创建三个线程类对象 Thread t1 = new Thread(ticket); Thread t2 = new Thread(ticket); Thread t3 = new Thread(ticket); // 给三个线程命名 t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); // 开启三个线程 t1.start(); t2.start(); t3.start(); } }
