多线程的创建、Thread类、线程安全、同步、通信 |
您所在的位置：网站首页 › 线程池常用 › 多线程的创建、Thread类、线程安全、同步、通信 |
多线程的创建、Thread类、线程安全、同步、通信
|
目录 多线程的创建 方式一：继承Thread类 方式二：实现Runnable接口 方式三：JDK 5.0新增：实现Callable接口 Thread的常用方法 线程安全 线程安全问题是什么、发生的原因 线程安全问题案例模拟 线程同步 同步思想概述 方式一：同步代码块 方式二：同步方法 方式三：Lock锁 线程通信【了解】 线程池【重点】 线程池概述 线程池实现的API、参数说明 线程池处理Runnable任务 线程池处理Callable任务 Executors工具类实现线程池 补充知识：定时器 补充知识：并发、并行 补充知识：线程的生命周期 多线程的创建 什么是线程？ 线程(thread)是一个程序内部的一条执行路径。 我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径。 程序中如果只有一条执行路径，那么这个程序就是单线程的程序。 多线程是什么？ 多线程是指从软硬件上实现多条执行流程的技术。 多线程用在哪里，有什么好处 再例如：消息通信、淘宝、京东系统都离不开多线程技术。
Thread的构造器 构造器 说明 public Thread(String name) 可以为当前线程指定名称 public Thread(Runnable target) 封装Runnable对象成为线程对象 public Thread(Runnable target ，String name ) 封装Runnable对象成为线程对象，并指定线程名称 /** * 目标：学会线程的创建方式二，理解它的优缺点。 */ public class Test { public static void main(String[] args) throws Exception { //3、创建一个任务对象 Runnable target = new MyRunnable(); //4、把任务对象交给Thread处理 Thread t = new Thread(target); //5、启动线程 t.start(); for (int i = 0; i < 5; i++) { System.out.println("主线程执行输出" + i); } } } /** * 1、定义一个线程任务类 实现Runnable接口 */ class MyRunnable implements Runnable { /** * 2、重写run方法，定义线程的执行任务的 */ @Override public void run() { for (int i = 0; i < 5; i++) { System.out.println("子线程执行输出：" + i); } } } 1、第二种方式是如何创建线程的？ 定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法 创建MyRunnable对象 把MyRunnable任务对象交给Thread线程对象处理。 调用线程对象的start()方法启动线程 2、第二种方式的优点 优点：线程任务类只是实现了Runnale接口，可以继续继承和实现。 缺点：如果线程有执行结果是不能直接返回的。 多线程的实现方案二：实现Runnable接口(匿名内部类形式) 可以创建Runnable的匿名内部类对象。 交给Thread处理。 调用线程对象的start()启动线程。 public class Test { public static void main(String[] args) throws Exception { //创建一个任务对象 // Runnable target = new Runnable() { // @Override // public void run() { // for (int i = 0; i < 5; i++) { // System.out.println("子线程执行输出：" + i); // } // } // }; Runnable target = () -> { for (int i = 0; i < 5; i++) { System.out.println("子线1程执行输出：" + i); } }; //把任务对象交给Thread处理 Thread t = new Thread(target); //启动线程 t.start(); new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 5; i++) { System.out.println("子线2程执行输出：" + i); } } }).start(); new Thread(() -> { for (int i = 0; i < 5; i++) { System.out.println("子线3程执行输出：" + i); } }).start(); for (int i = 0; i < 5; i++) { System.out.println("主线程执行输出" + i); } } } 方式三：JDK 5.0新增：实现Callable接口 1、前2种线程创建方式都存在一个问题： 他们重写的run方法均不能直接返回结果。 不适合需要返回线程执行结果的业务场景。 2、怎么解决这个问题呢？ JDK 5.0提供了Callable和FutureTask来实现。 这种方式的优点是：可以得到线程执行的结果。 多线程的实现方案三：利用Callable、FutureTask接口实现。 1、得到任务对象 定义类实现Callable接口，重写call方法，封装要做的事情。 用FutureTask把Callable对象封装成线程任务对象。 2、把线程任务对象交给Thread处理。 3、调用Thread的start方法启动线程，执行任务 4、线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。FutureTask的API 方法名称 说明 public FutureTask(Callable call) 把Callable对象封装成FutureTask对象。 public V get() throws Exception 获取线程执行call方法返回的结果。 import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; /** * 目标：学会线程的创建方式三：实现Callable接口，结合FutureTask完成。 */ public class Test { public static void main(String[] args) { //3、创建Callable任务对象 Callable callable1 = new MyCallable(100); //4、把Callable任务对象交给FutureTask对象 // FutureTask对象的作用1： 是Runnable的对象（实现了Runnable接口），可以交给Thread了 // FutureTask对象的作用2： 可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果 FutureTask f1 = new FutureTask(callable1); //5、交给线程处理 Thread t1 = new Thread(f1); //6、启动线程 t1.start(); Callable callable2 = new MyCallable(200); FutureTask f2 = new FutureTask(callable2); Thread t2 = new Thread(f2); t2.start(); try { // 如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果。 String rs1 = f1.get(); System.out.println("第一个结果" + rs1); } catch (Exception e) { e.printStackTrace(); } try { // 如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果。 String rs2 = f2.get(); System.out.println("第二个结果" + rs2); } catch (Exception e) { e.printStackTrace(); } } } /** * 1、定义一个任务类，实现Callable接口 应该申明线程任务执行完毕后的结果的数据类型 */ class MyCallable implements Callable { private int n; public MyCallable(int n) { this.n = n; } /** * 2、重写方法 */ @Override public String call() throws Exception { int sum = 0; for (int i = 0; i = money) { //3、取钱 System.out.println(name + "来取钱成功，取出：" + money); //4、更新账户金额 this.money -= money; System.out.println(name+"来取钱后剩余"+this.money); }else { //5、金额不足 System.out.println(name+"来取钱，余额不足！"); } } 锁对象用任意唯一的对象好不好呢? 不好，会影响其他无关线程的执行。 锁对象的规范要求 规范上：建议使用共享资源作为锁对象。 对于实例方法建议使用this作为锁对象。 对于静态方法建议使用字节码（类名.class）对象作为锁对象。 1、同步代码块是如何实现线程安全的？ 对出现问题的核心代码使用synchronized进行加锁 每次只能一个线程占锁进入访问 2. 同步代码块的同步锁对象有什么要求？ 对于实例方法建议使用this作为锁对象。 对于静态方法建议使用字节码（类名.class）对象作为锁对象。 /** * 对于静态方法建议使用字节码（类名.class）对象作为锁对象 */ // public static void run(){ // synchronized (Account.class){ // // } // } //小明 小红 public void drawMoney(double money) { //1、先获取是谁来取钱，线程的名字就是人名 String name = Thread.currentThread().getName(); /** *同步代码块 * 锁住操作共享资源的代码(核心代码) * this == acc 共享账户 */ synchronized (this) { //1、判断账户是否够钱 if (this.money >= money) { //3、取钱 System.out.println(name + "来取钱成功，取出：" + money); //4、更新账户金额 this.money -= money; System.out.println(name+"来取钱后剩余"+this.money); }else { //5、金额不足 System.out.println(name+"来取钱，余额不足！"); } } } 方式二：同步方法 同步方法 作用：把出现线程安全问题的核心方法给上锁。 原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。 格式： 修饰符 synchronized 返回值类型 方法名称(形参列表) { 操作共享资源的代码 } 同步方法底层原理 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。 如果方法是实例方法：同步方法默认用this作为的锁对象。但是代码要高度面向对象！ 如果方法是静态方法：同步方法默认用类名.class作为的锁对象。 public synchronized void drawMoney(double money) { //1、先获取是谁来取钱，线程的名字就是人名 String name = Thread.currentThread().getName(); //1、判断账户是否够钱 if (this.money >= money) { //3、取钱 System.out.println(name + "来取钱成功，取出：" + money); //4、更新账户金额 this.money -= money; System.out.println(name+"来取钱后剩余"+this.money); }else { //5、金额不足 System.out.println(name+"来取钱，余额不足！"); } } 1、是同步代码块好还是同步方法好一点？ 同步代码块锁的范围更小，同步方法锁的范围更大。 总结 1、同步方法是如何保证线程安全的？ 对出现问题的核心方法使用synchronized修饰 每次只能一个线程占锁进入访问 2、同步方法的同步锁对象的原理？ 对于实例方法默认使用this作为锁对象。 对于静态方法默认使用类名.class对象作为锁对象。 方式三：Lock锁 Lock锁 为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，更加灵活、方便。 Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作。 Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象。方法名称 说明 public ReentrantLock() 获得Lock锁的实现类对象 Lock的API 方法名称 说明 void lock() 获得锁 void unlock() 释放锁 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class Account { private String cardId;//卡号 private double money;//账户金额 //final修饰后：锁对象是唯一不可替换的，非常专业！ private final Lock lock = new ReentrantLock(); public Account() { } public Account(String cardId, double money) { this.cardId = cardId; this.money = money; } //小明 小红 public void drawMoney(double money) { //1、先获取是谁来取钱，线程的名字就是人名 String name = Thread.currentThread().getName(); //2、判断账户是否够钱 lock.lock();//上锁 try { if (this.money >= money) { //3、取钱 System.out.println(name + "来取钱成功，取出：" + money); //4、更新账户金额 this.money -= money; System.out.println(name + "来取钱后剩余" + this.money); //System.out.println(10/0);//解锁放进finally避免出现bug不能解锁 } else { //5、金额不足 System.out.println(name + "来取钱，余额不足！"); } } finally { lock.unlock();//解锁 } } public String getCardId() { return cardId; } public void setCardId(String cardId) { this.cardId = cardId; } public double getMoney() { return money; } public void setMoney(double money) { this.money = money; } } 线程通信【了解】 什么是线程通信、如何实现？ 所谓线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信。 线程通信常见形式 通过共享一个数据的方式实现。 根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。 线程通信实际应用场景 生产者与消费者模型： 生产者线程负责生产数据，消费者线程负责消费生产者产生的数据。 要求：生产者线程生产完数据后唤醒消费者，然后等待自己， 消费者消费完该数据后唤醒生产者，然后等待自己。Object类的等待和唤醒方法： 方法名称 说明 void wait() 让当前线程等待并释放所占锁，直到另一个线程调用notify()方法或 notifyAll()方法 void notify() 唤醒正在等待的单个线程 void notifyAll() 唤醒正在等待的所有线程 注意 上述方法应该使用当前同步锁对象进行调用。 线程池【重点】 线程池概述 什么是线程池？ 线程池就是一个可以复用线程的技术。 不使用线程池的问题 如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程， 而创建新线程的开销是很大的，这样会严重影响系统的性能。线程池的工作原理
ThreadPoolExecutor构造器的参数说明
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
ExecutorService的常用方法 方法名称 说明 void execute(Runnable command) 执行任务/命令，没有返回值，一般用来执行 Runnable 任务 Future submit(Callable task) 执行任务，返回未来任务对象获取线程结果，一般拿来执行 Callable 任务 void shutdown() 等任务执行完毕后关闭线程池 List shutdownNow() 立刻关闭，停止正在执行的任务，并返回队列中未执行的任务 新任务拒绝策略 策略 详解 ThreadPoolExecutor.AbortPolicy 丢弃任务并抛出RejectedExecutionException异常。是默认的策略 ThreadPoolExecutor.DiscardPolicy： 丢弃任务，但是不抛出异常 这是不推荐的做法 ThreadPoolExecutor.DiscardOldestPolicy 抛弃队列中等待最久的任务 然后把当前任务加入队列中 ThreadPoolExecutor.CallerRunsPolicy 由主线程负责调用任务的run()方法从而绕过线程池直接执行 public class MyRunnable implements Runnable{ @Override public void run() { for (int i = 0; i < 5; i++) { System.out.println(Thread.currentThread().getName() + "输出了：HelloWorld ==> " + i); } try { System.out.println(Thread.currentThread().getName() + "本任务与线程绑定了，线程进入休眠了~~~"); Thread.sleep(10000000); } catch (Exception e) { e.printStackTrace(); } } } import java.util.concurrent.*; /** 目标：自定义一个线程池对象，并测试其特性。 */ public class ThreadPoolDemo1 { public static void main(String[] args) { // 1、创建线程池对象 /** public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) */ ExecutorService pool = new ThreadPoolExecutor(3, 5 , 6, TimeUnit.SECONDS, new ArrayBlockingQueue(5) , Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy() ); // 2、给任务线程池处理。 Runnable target = new MyRunnable(); pool.execute(target); pool.execute(target); pool.execute(target); pool.execute(target); pool.execute(target); pool.execute(target); pool.execute(target); pool.execute(target); // 创建临时线程 pool.execute(target); pool.execute(target); // // 不创建，拒绝策略被触发！！！ // pool.execute(target); // 关闭线程池（开发中一般不会使用）。 // pool.shutdownNow(); // 立即关闭，即使任务没有完成，会丢失任务的！ pool.shutdown(); // 会等待全部任务执行完毕之后再关闭（建议使用的） } } 线程池处理Callable任务ExecutorService的常用方法 方法名称 说明 void execute(Runnable command) 执行任务/命令，没有返回值，一般用来执行 Runnable 任务 Future submit(Callable task) 执行Callable任务，返回未来任务对象获取线程结果 void shutdown() 等任务执行完毕后关闭线程池 List shutdownNow() 立刻关闭，停止正在执行的任务，并返回队列中未执行的任务 import java.util.concurrent.Callable; /** 1、定义一个任务类 实现Callable接口 应该申明线程任务执行完毕后的结果的数据类型 */ public class MyCallable implements Callable{ private int n; public MyCallable(int n) { this.n = n; } /** 2、重写call方法（任务方法） */ @Override public String call() throws Exception { int sum = 0; for (int i = 1; i |
【本文地址】
今日新闻 |
推荐新闻 |