目录
线程(thread): 是一个程序内部的一条执行路经(之前写的代码中,main方法的执行就是一条单独的执行路径)
线程安全: 多个线程同时操作一个共享资源的时候可能出现业务安全问题
线程(thread): 是一个程序内部的一条执行路经(之前写的代码中,main方法的执行就是一条单独的执行路径)
单线程: 一个程序只有一条执行路线
多线程: 指从软硬件上实现多条执行流程的技术
一.创建多线程
1.继承Thread类
步骤:
(1)定义一个子类继承Thread,然后重写run()方法
(2)创建子类的对象
(3)调用子类对象的start()方法启动线程(启动后执行的是run()方法)
代码示范: 第一段是子类的代码, 第二段是测试类的代码
//1.定义一个子类继承Thread,重写run方法 public class MyThread extends Thread{ @Override public void run() { for (int i = 0; i < 5; i++) { System.out.println("子线程"+i); } } }public class ThreadDemo1 { public static void main(String[] args) { //2.创建子线程对象 MyThread mt = new MyThread(); //3.调用start()方法启动子线程(启动后执行的是run()方法) mt.start(); for (int i = 0; i < 5; i++) { System.out.println("主线程"+i); } } }结果展示: (主线程和子线程的执行没有先后之分)(要将主线程的执行任务放在子线程之后,)
用继承Thread类创建多线程的优点和缺点
优点: 编程简单
缺点: 线程类已经继承Thread类, 无法继承其他类
2.实现Runnable接口
步骤:
(1)定义一个线程任务类实现Runnable接口, 重写run( )方法
(2)创建任务对象
(3)将任务对象交给Thread处理表
(3)调用线程对象的start( )方法启动线程
代码示范: 第一段是类的代码,第二段是测试的代码
//创建多线程:子类实现Runnable接口 public class MyThread1 implements Runnable{ @Override public void run() { for (int i = 0; i < 5; i++) { System.out.println("子线程"+i); } } }public class Test1 { public static void main(String[] args) { /*第一种写法//创建任务对象,任务对象不是Thread的子类,无法直接调用start()方法 MyThread1 mt = new MyThread1(); //把任务对象交给Thread处理 Thread t1 = new Thread(mt); //调用start()方法 t.start();*/ /*第二种写法 Thread t2 = new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 5; i++) { System.out.println("子线程"+i); } } }); t2.start();*/ //第三种写法 Thread t3 = new Thread(() -> { for (int i = 0; i < 5; i++) { System.out.println("子线程" + i); } }); t3.start(); for (int i = 0; i < 5; i++) { System.out.println("主线程" + i); } } }结果展示:
优点: 线程任务类只是实现接口, 可以继续继承类和实现接口,扩展性强
缺点: 编程要多一层对象包装, 如果线程有执行结果无法直接返回
3.利用Callable, FutureTask接口实现
步骤:
(1)定义类实现Callable接口,重写call方法, 封装要做的事
(2)用FutureTask把Callable对象封装成线程任务对象
(3)把线程任务对象交给Thread处理
(4)调用Thread的start方法启动线程
(5)线程执行完毕后, 通过FutureTask的get方法获取执行结果
代码示范: 第一段是类的代码, 第二段是测试的代码
import java.util.concurrent.Callable; public class MyCallable implements Callable<String> { private int n; public MyCallable(int n) { this.n = n; } @Override public String call() throws Exception { int sum = 0; for (int i = 0; i <= n; i++) { sum += i; } return "结果是"+sum; } }import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; public class Test2 { public static void main(String[] args) throws ExecutionException, InterruptedException { //子线程1的代码 //创建任务类对象 MyCallable call1 = new MyCallable(50); //用FutureTask把Callable对象封装成线程任务对象 FutureTask<String> f1 = new FutureTask<>(call1); //把线程对象交给Thread处理 Thread t1 = new Thread(f1); //通过调用start方法启动线程 t1.start(); //线程执行完毕后,通过FutureTask的get方法获取任务执行结果 String s1 = f1.get(); System.out.println("子线程1的"+s1); //子线程2的代码 MyCallable call2 = new MyCallable(100); //用FutureTask把Callable对象封装成线程任务对象 FutureTask<String> f2 = new FutureTask<>(call2); //把线程对象交给Thread处理 Thread t2 = new Thread(f2); //通过调用start方法启动线程 t2.start(); //线程执行完毕后,通过FutureTask的get方法获取任务执行结果 String s2 = f2.get(); System.out.println("子线程2的"+s2); } }结果展示:
优点: 线程任务类只是实现接口可以继续继承类和实现接口, 扩展性强
可以在线程完毕后去获取线程执行的结果
缺点: 代码有点复杂
二.Thread的常用方法
1.Thread的构造方法
方法名称 说明
public Thread(String name) 可以为当前线程指定名称
public Thread(Runnable target) 封装Runnable对象成为线程对象
public Thread(Runnable target ，String name ) 封装Runnable对象成为线程对象，并指定线程名称2.Thread获取和设置线程名称
方法名称 说明
String getName() 获取当前线程的名称，默认线程名称是Thread-索引
void setName(String name) 将此线程的名称更改为指定的名称，通过构造器也可以设置线程名称3.Thread类获得当前线程的对象
方法名称 说明
public static Thread currentThread() 返回对当前正在执行的线程对象的引用
代码示范: 第一段类的代码, 第二段是测试的代码public class MyThread extends Thread{ public MyThread() { } //调用父类的方法 public MyThread(String name) { super(name); } @Override public void run() { for (int i = 0; i < 5; i++) { System.out.println(currentThread().getName()+"输出: "+i); } } }import static java.lang.Thread.currentThread; public class ThreadAPI { public static void main(String[] args) { Thread t1 = new MyThread("一号子线程"); //t1.setName("一号");//设置线程名称 t1.start(); Thread t2 = new MyThread("二号子线程"); t2.start(); //输出子线程1的名称 System.out.println(t1.getName()); //输出子线程2的名称 System.out.println(t2.getName()); //输出主线程的名称 System.out.println(currentThread().getName()); //设置主线程名称 currentThread().setName("主线程"); for (int i = 0; i < 5; i++) { System.out.println(currentThread().getName()+"输出: "+ i); } } }结果展示:
扩展:Thread类的线程休眠方法
方法名称 说明
public static void sleep(long time) 让当前线程休眠指定的时间后再继续执行，单位为毫秒
代码示范:mport static java.lang.Thread.currentThread; public class Test { public static void main(String[] args) throws InterruptedException { for (int i = 1; i <= 5; i++) { if(i==3){ Thread.sleep(5000); } System.out.println(currentThread().getName()+"输出: "+i); } } }
三.线程安全
线程安全: 多个线程同时操作一个共享资源的时候可能出现业务安全问题
原因:多个线程同时访问同一个共享资源且存在修改该资源
如: 两个人在同一个账户取钱
代码示范:
public class Account { private String Id;//卡号 private double money;//账户余额 public Account() { } public Account(String Id, double money) { this.Id = Id; this.money = money; } /** * 获取 * * @return Id */ public String getId() { return Id; } /** * 设置 * * @param Id */ public void setId(String Id) { this.Id = Id; } /** * 获取 * * @return money */ public double getMoney() { return money; } /** * 设置 * * @param money */ public void setMoney(double money) { this.money = money; } public String toString() { return "Account{Id = " + Id + ", money = " + money + "}"; } public void drawMoney(double money) { //1.谁来取钱 String name = Thread.currentThread().getName(); //2.判断钱是否足够 if (this.money >= money) { //3.取钱 System.out.println(name + "来取钱成功,吐出: " + money); //4.更新余额 this.money -= money; System.out.println(name+"来取钱后,剩余: "+this.money); }else{ System.out.println(name+"来取钱失败,余额不足"); } } }public class DrawThread extends Thread{ //接收处理的账户对象 private Account acc; public DrawThread(Account acc,String name) { super(name); this.acc = acc; } @Override public void run() { //取钱 acc.drawMoney(100000); } }public class Test1 { public static void main(String[] args) { //创建一个共享账户 Account acc = new Account("abc-123",100000); //创建两个线程,代表两个人来取钱 new DrawThread(acc,"小明").start(); new DrawThread(acc,"小红").start(); } }结果展示:
四.线程同步
加锁: 让多个线程实现先后依次访问共享资源
1.同步代码块
(1)作用: 把出现线程安全问题的核心代码上锁
(2)原理: 每次只能一个线程进入, 执行完毕后自动解锁, 其他线程才可以进来执行
(3)格式: synchronized(同步锁对象){
操作共享资源的代码(核心代码)
}
(4)锁对象的规范要求:
建议使用共享资源作为锁对象
对于实例方法建议使用this作为锁对象
对于静态方法建议使用字节码 (类名.class)对象作为锁对象
(格式:synchronized (类名.class){ })
以上一个取钱的线程安全问题为例
修改后的结果展示:
2.同步方法
作用: 把出现线程安全问题的核心方法给上锁
原理: 每次只能一个线程进入, 执行完毕之后自动解锁, 其他线程才可以进来执行
格式: 修饰符 synchronized 返回类型 方法名称(形参列表){
操作共享资源的代码
}
以上一个取钱的线程安全问题为例
修改后的结果展示:
3.Lock锁
为了更清晰的表达如何加锁和释放锁, JDK5以后提供了一个新的锁对象Lock, 更加灵活,方便Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象
方法名称 说明
public ReentrantLock() 获得Lock锁的实现类对象
Lock的API
方法名称 说明
void lock() 获得锁
void unlock() 释放锁代码示范: 使用Lock锁对Account类进行修改
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class Account { private String Id;//卡号 private double money;//账户余额 private final Lock lock = new ReentrantLock();//用final修饰,锁对象是唯一且不可替换的 public Account() { } public Account(String Id, double money) { this.Id = Id; this.money = money; } public void drawMoney(double money) { //1.谁来取钱 String name = Thread.currentThread().getName(); lock.lock();//上锁 //2.判断钱是否足够(核心代码) try { if (this.money >= money) { //3.取钱 System.out.println(name + "来取钱成功,吐出: " + money); //4.更新余额 this.money -= money; System.out.println(name + "来取钱后,剩余: " + this.money); } else { System.out.println(name + "来取钱失败,余额不足"); } } finally { lock.unlock();//解锁 } } /** * 获取 * * @return Id */ public String getId() { return Id; } /** * 设置 * * @param Id */ public void setId(String Id) { this.Id = Id; } /** * 获取 * * @return money */ public double getMoney() { return money; } /** * 设置 * * @param money */ public void setMoney(double money) { this.money = money; } public String toString() { return "Account{Id = " + Id + ", money = " + money + "}"; } }结果展示:
五.线程通信
什么是线程通信、如何实现?
所谓线程通信就是线程间相互发送数据，线程通信通常通过共享一个数据的方式实现
线程间会根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做线程通信常见模型
生产者与消费者模型:生产者线程负责生产数据，消费者线程负责消费数据(一产一消)
要求:生产者线程生产完数据后，唤醒消费者，然后等待自己(把自己关闭, 把cpu占的空间腾出来,提高运行效率);消费者消费完该数据后，唤醒生产者，然后等待自己
六.线程池
1.线程池就是一个可以复用线程的技术
如果不使用线程池的问题会产生什么问题?
如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能JDK 5.0起提供了代表线程池的接口: ExecutorService
如何得到线程池对象?
1.使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
2.使用Executors (线程池的工具类) 调用方法返回不同特点的线程池对象
ThreadPoolExecutor构造方法的参数说明
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingOueue<Runnable> workQueue ,
ThreadFactory threadFactory，
RejectedExecutionHandler handler)
参数一:指定线程池的线程数量(核心线程): corePoolSize------->不能小于0
参数二:指定线程池可支持的最大线程数: maximumPoolsize------>最大数量>=核心线程数量
参数三:指定临时线程的最大存活时间: keepAliveTime-------->不能小于0
参数四:指定存活时间的单位(秒、分、时、天): unit--------->时间单位
参数五:指定任务队列(在等待执行的任务): workQueue---------->不能为null
参数六:指定用哪个线程工厂创建线程: threadFactory---------->不能为null
参数七:指定线程忙，任务满的时候，新任务来了怎么办: handler--------->不能为null2.线程池常见面试题
临时线程什么时候创建?
新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程
什么时候会开始拒绝任务?
核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝3.ExecutorService的常用方法
方法名称 说明
void execute(Runnable command) 执行任务/命令,没有返回值,一般用来执Runnable任务
Future<T> submit(Callable<T> task) 执行任务，返回未来任务对象获取线程结果，一般拿来执行 callable 任务
void shutdown() 等任务执行完毕后关闭线程池
List<Runnable> shutdownNow() 立刻关闭，停止正在执行的任务，并返回队列中未执行的任务代码示范: 处理Runnable任务
public class MyRunnable extends Thread{ @Override public void run() { for (int i = 1; i < 4; i++) { System.out.println(Thread.currentThread().getName()+"输出: "+i); } System.out.println(Thread.currentThread().getName()+"完成一次"); } }import java.util.concurrent.*; public class Test1 { public static void main(String[] args) { /*public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)*/ ExecutorService pool = new ThreadPoolExecutor(3,6,4 ,TimeUnit.SECONDS,new ArrayBlockingQueue<>(5),Executors.defaultThreadFactory() ,new ThreadPoolExecutor.AbortPolicy()); Runnable mr = new MyRunnable(); pool.execute(mr); pool.execute(mr); pool.execute(mr); pool.execute(mr); pool.execute(mr); pool.execute(mr); } }结果展示:
代码示范: 处理Callable任务
import java.util.concurrent.Callable; public class MyCallable implements Callable<String> { private int n; public MyCallable(int n) { this.n = n; } @Override public String call() throws Exception { int sum = 0; for (int i = 1; i <= n; i++) { sum += i; } return Thread.currentThread().getName()+"输出: "+sum; } }import java.util.concurrent.*; public class Test2 { public static void main(String[] args) throws ExecutionException, InterruptedException { ExecutorService pool = new ThreadPoolExecutor(3,6,4 , TimeUnit.SECONDS,new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory() ,new ThreadPoolExecutor.AbortPolicy()); Future<String> f1 = pool.submit(new MyCallable(100)); Future<String> f2 = pool.submit(new MyCallable(200)); Future<String> f3 = pool.submit(new MyCallable(300)); Future<String> f4 = pool.submit(new MyCallable(400)); Future<String> f5 = pool.submit(new MyCallable(500)); System.out.println(f1.get()); System.out.println(f2.get()); System.out.println(f3.get()); System.out.println(f4.get()); System.out.println(f5.get()); } }结果展示:
4.Executors得到线程池对象的常用方法
Executors:线程池的工具类通过调用方法返回不同类型的线程池对象
(1)public static ExecutorService newCachedThreadPool() 线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了一段时间则会被回收掉
(2)public static ExecutorService newFixedThreadPool(int nThreads) 创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它
(3)public static ExecutorService newSingleThreadExecutor () 创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程
(4)public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务
注意:Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的代码示范:
public class MyRunnable extends Thread{ @Override public void run() { for (int i = 1; i < 4; i++) { System.out.println(Thread.currentThread().getName()+"输出: "+i); } System.out.println(Thread.currentThread().getName()+"完成完成本轮输出"); } }import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Test3 { public static void main(String[] args) { //创建固定线程数量的线程池 ExecutorService pool = Executors.newFixedThreadPool(2); pool.execute(new MyRunnable()); pool.execute(new MyRunnable()); pool.execute(new MyRunnable()); pool.execute(new MyRunnable()); } }结果展示:
缺点: Executors不适合做大型互联网场景的线程池方案
建议使用ThreadPoolExecutor来指定线程池参数，这样可以明确线程池的运行规则规避资源耗尽的风险
9万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
