Java 多线程、线程同步、线程池
一. 线程
1. 线程：线程(Thread)是一个程序内部的一条执行流程。
2. 程序中如果只有一条执行流程，那这个程序就是单线程的程序。
二. 多线程
多线程是指从硬件上实现多条执行流程的技术(多条线程由CPU负责调度)
Javas是通过java.lang.Thread类的对象来代表线程的
1. 多线程的创建方式一：继承Thread类
① 定义一个子类继承线程类(java.lang.Thread)，重写run()方法
② 创建子类线程对象
③ 调用线程对象的start()方法启动线程(启动后还是执行的run方法)
优点：编码简单；
缺点：线程继承了Thread类，无法继承其他类，不利于线程的扩展
注意事项：启动线程必须调用start()方法，不是调用run()方法；不要把主线程任务放在启动子线程之前
/*
* 1. 让子类继承Thread线程类
* */
public class MyThread extends Thread {
//2.重写 run方法
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("子线程类:" + i);
}
}
}
public class Test1_Thread {
//main方法是由一条默认的主线程负责执行
public static void main(String[] args) {
//创建线程类对象
Thread t = new MyThread();
//启动线程
t.start();//main线程的子线程
//主线程任务在后
//不要把主线程任务放在启动子线程之前(会导致执行完主线程任务后才会启动子线程)
for (int i = 0; i < 10; i++) {
System.out.println("主线程：" + i);
}
}
}2. 多线程的创建方式二：实现Runnable接口
① 定义一个线程任务类实现Runnable接口，重写run()方法；
② 创建任务类对象
③ 把任务类对象交给Thread处理(public Thread(Runnable target))
④ 调用线程对象的start()方法启动线程
优点：任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强
缺点：需要多创建一个Runnable对象
/*
* implements Runnable 实现Runnable接口
* */
public class MyRunnable implements Runnable {
//重写run方法
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("子线程：" + i);
}
}
}
public class Test2_Runnable {
public static void main(String[] args) {
//创建任务对象
Runnable r = new MyRunnable();
//把任务对象交给一个线程对象处理 public Thread(Runnable target)
new Thread(r).start();
//主线程
for (int i = 0; i < 10; i++) {
System.out.println("主线程" + i);
}
}
}
public class Test3_Runnable {
public static void main(String[] args) {
//使用匿名内部类创建线程
//1.直接创建Runnable接口的匿名内部类形式
Runnable r = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("子线程" + i);
}
}
};
//启动线程
new Thread(r).start();
//简化1
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("子线程2" + i);
}
}
}).start();
//简化2
new Thread(() ->{
for (int i = 0; i < 10; i++) {
System.out.println("子线程3" + i);
}
}).start();
//主线程
for (int i = 0; i < 10; i++) {
System.out.println("主线程" + i);
}
}
}
3. 多线程的创建方式三：实现Callable接口
前面两种线程创建方式都存在一个问题：他们重写的run方法均不能直接返回结果；JDK5.0提供了Callable接口和FutureTask类来实现(多线程的第三种创建方式) ：可以直接返回线程执行的结果
(1) 创建任务对象：定义一个类实现Callable接口，重写call方法，封装要做的事情和要返回的数据。把Callable类型的对象封装成FutureTask(线程任务对象)。
(2) 把任务类对象交给Thread处理(public Thread(Runnable target))
(3) 调用线程对象的start()方法启动线程
(4) 线程执行完毕后、通过FutureTask对象的get方法去获取线程任务执行的结果。
| FutureTask提供的构造器 | 说明 |
| public FutureTask<>(Callable call) | 把Callable对象封装成FutureTask对象 |
| FutureTask提供的方法 | 说明 |
| public V get() throws Exception | 获取线程call方法返回的结果 |
public class MyCallable implements Callable<String> {
private int num;
public MyCallable(int num) {
this.num = num;
}
@Override
public String call() throws Exception {
int sum = 0;
for (int i = 0; i < num; i++) {
sum = sum + i;
}
return "sum:" + sum;
}
}
public class Test4_Callable {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//(1) 创建任务对象：定义一个类实现Callable接口，重写call方法，封装要做的事情和要返回的数据。
Callable<String> callable = new MyCallable(10);
//把Callable类型的对象封装成FutureTask(线程任务对象)。
FutureTask<String> futureTask = new FutureTask<>(callable);
// (2) 把任务类对象交给Thread处理(public Thread(Runnable target))
//(3) 调用线程对象的start()方法启动线程
new Thread(futureTask).start();
//(4) 线程执行完毕后、通过FutureTask对象的get方法去获取线程任务执行的结果。
// 假如上面的线程还没有执行完成，这里的代码会暂停，等待上面线程执行完毕后才会获取结果
String s = futureTask.get();
System.out.println(s);
}
}三. Thread的常用方法
| Thread提供的常用方法 | 说明 |
| public void run() | 线程的任务方法 |
| public void start() | 启动线程 |
| public String getName() | 获取当前线程的名称，线程名称默认是Thread-索引 |
| public void setName(String name) | 设置线程名称 |
| public static Thread currentThread() | 获取当前执行的线程对象 |
| public static void sleep(long time) | 让当前执行的线程休眠多少毫秒后，再继续执行 |
| public final void join() ... | 让调用当前这个方法的线程先执行完 |
| Thread提供的常见构造器 | 说明 |
| public Thread(String name) | 设置当前线程名称 |
| public Thread(Runnable target) | 封装Runnable对象为线程对象 |
| public Thread(Runnable target, String name) | 封装Runnable对象为线程对象，并指定线程名称 |
public class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
public MyThread(){
super();
}
//2.重写 run方法
public void run() {
Thread t = Thread.currentThread();
for (int i = 0; i < 10; i++) {
System.out.println(t.getName() + "线程:" + i);
}
}
}
public static void main(String[] args) throws Exception {
//Thread的常用方法
Thread t1 = new MyThread();
Thread t2 = new MyThread();
t1.start();
t2.start();
//主线程
for (int i = 0; i < 10; i++) {
//public static void sleep(long time) 让当前执行的线程休眠多少毫秒后，再继续执行
if (i == 5 ){
Thread.sleep(2000);
}
System.out.println("主线程" + i);
}
//public String getName() 获取当前线程的名称，线程名称默认是Thread-索引
System.out.println(t1.getName());//Thread-0
System.out.println(t2.getName());//Thread-1
//public void setName(String name) 设置线程名称
t1.setName("线程1");
t2.setName("线程2");
System.out.println(t1.getName());//线程1
System.out.println(t2.getName());//线程2
//public static Thread currentThread() 获取当前执行的线程对象
// 哪个线程执行他，就会得到哪个线程对象
Thread m = Thread.currentThread();
System.out.println(m.getName());//main
m.setName("主线程");
System.out.println(m.getName());//主线程
//public Thread(String name) 设置当前线程名称
Thread t3 = new MyThread("线程3");
System.out.println(t3.getName());//线程3
//public final void join() ... 让调用当前这个方法的线程先执行完
Thread t4 = new MyThread("线程4");
t4.start();
t4.join();
Thread t5 = new MyThread("线程5");
t5.start();
t5.join();
Thread t6 = new MyThread("线程6");
t6.start();
t6.join();
}四. 线程安全
线程安全问题：多个线程，同时操作同一个共享资源的时候，可能会出现业务安全问题。
//账户类
public class Account {
private double balance;
private String accountId;
public Account(double balance, String accountId) {
this.balance = balance;
this.accountId = accountId;
}
public Account() {
}
//取钱方法
public void deposit(double amount) {
String name = Thread.currentThread().getName();
if (this.balance >= amount ) {
System.out.println(
name + "取钱" + amount + " 成功"
);
balance = balance - amount;
System.out.println(name + "余额" + this.balance);
}else {
System.out.println(name + "取钱" + amount + "余额不足");
}
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public String getAccountId() {
return accountId;
}
public void setAccountId(String accountId) {
this.accountId = accountId;
}
}
//取钱线程
public class depositThread extends Thread{
private Account account;
public depositThread(Account account, String name) {
super(name);
this.account = account;
}
public void run() {
account.deposit(100000);
}
}
//main测试方法
public static void main(String[] args) {
Account account = new Account(100000, "147852963" );
new depositThread(account, "朵朵").start();
new depositThread(account, "大宇").start();
}
五. 线程同步
线程同步：解决线程安全问题的方案：让多个线程先后依次的访问共享资源；
常见方案：加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能在加锁进来。
1. 方式一：同步代码块
作用：把访问共享资源的核心代码给上锁，保证线程安全
格式：synchronized(同步锁){
访问公共资源的核心代码块
}
原理：每次只允许一个线程加锁进去，执行完毕后自动解锁，其他线程才可以进来执行
注意事项：对于当前执行的线程来说，同步锁必须是同一个对象，否则会出bug
锁对象的使用规范：
① 建议使用共享资源作为锁对象，对于实例方法建议使用this作为锁对象
② 对于静态方法建议使用字节码(类名.class)对象作为锁对象
//取钱方法
public void deposit(double amount) {
String name = Thread.currentThread().getName();
synchronized (this) {
if (this.balance >= amount ) {
System.out.println(
name + "取钱" + amount + " 成功"
);
balance = balance - amount;
System.out.println(name + "余额" + this.balance);
}else {
System.out.println(name + "取钱" + amount + "余额不足");
}
}
}
//如果为静态方法
public static void deposit1(double amount) {
String name = Thread.currentThread().getName();
synchronized (Account.class) {
}
}
public static void main(String[] args) {
Account account = new Account(100000, "147852963" );
new depositThread(account, "朵朵").start();//
new depositThread(account, "大宇").start();
Account account1 = new Account(150000, "88888888" );
new depositThread(account1, "欢欢").start();//
new depositThread(account1, "麦琪").start();
}
2. 方式二：同步方法
作用：把访问共享资源的核心方法上锁，保证线程安全
格式： 修饰符 synchronized 返回值类型 方法名称(形参列表){
操作共享资源的代码
}
原理：每次只允许一个线程加锁进去，执行完毕后自动解锁，其他线程才可以进来执行
同步方法的底层原理：
① 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码
② 如果方法是实例方法：同步方法默认用this作为锁对象
③ 如果方法是静态方法：同步方法默认用类名.class作为锁对象
public synchronized void deposit(double amount) {
String name = Thread.currentThread().getName();
if (this.balance >= amount ) {
System.out.println(
name + "取钱" + amount + " 成功"
);
balance = balance - amount;
System.out.println(name + "余额" + this.balance);
}else {
System.out.println(name + "取钱" + amount + "余额不足");
}
}
public static void main(String[] args) {
Account account = new Account(100000, "147852963" );
new depositThread(account, "朵朵").start();//
new depositThread(account, "大宇").start();
Account account1 = new Account(150000, "88888888" );
new depositThread(account1, "欢欢").start();//
new depositThread(account1, "麦琪").start();
}
3. 方式三： Lock锁
Lock锁是jdk5开始提供的一个新的锁定方式，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。
Lock是接口，不能直接实例化，可以采用他的实现类ReentrantLock来构建Lock对象
| 构造器 | 说明 |
| public ReentrantLock() | 获得Lock锁的实现类对象 |
| 常用方法 | 说明 |
| void lock() | 获得锁 |
| void unlock() | 释放锁 |
public class Account {
private double balance;
private String accountId;
//创建一个锁对象
private final Lock lock = new ReentrantLock();
public Account(double balance, String accountId) {
this.balance = balance;
this.accountId = accountId;
}
public Account() {
}
public void deposit(double amount) {
String name = Thread.currentThread().getName();
try {
lock.lock();//加锁
if (this.balance >= amount ) {
System.out.println(
name + "取钱" + amount + " 成功"
);
balance = balance - amount;
System.out.println(name + "余额" + this.balance);
}else {
System.out.println(name + "取钱" + amount + "余额不足");
}
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
lock.unlock();//解锁
}
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public String getAccountId() {
return accountId;
}
public void setAccountId(String accountId) {
this.accountId = accountId;
}
}
public static void main(String[] args) {
Account account = new Account(100000, "147852963" );
new depositThread(account, "朵朵").start();//
new depositThread(account, "大宇").start();
Account account1 = new Account(150000, "88888888" );
new depositThread(account1, "欢欢").start();//
new depositThread(account1, "麦琪").start();
}
六. 线程通信
1. 线程通信：当多个线程共同操作共享资源时，线程间通过某种方式互相告知自己的状态，以相互协调，避免无效的资源争夺
| Object类的等待和唤醒方法 | 说明 |
| void wait() | 让当前线程等待并释放所占锁，直到另一个线程调用notify()方法或notify()方法 |
| void notify() | 唤醒正在等待的单个线程 |
| void notifyAll() | 唤醒正在等待的所有线程 |
上述方法应当使用当前同步的锁对象进行调用。
七. 线程池
线程池：就是一个可以复用线程的技术。
不使用线程池的问题：用户每发起一个请求，后台就需要创建一个新的线程来处理，而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，会影响系统的性能。
1. 创建线程池方式一实现类ThreadPoolExecutor
JDK5..0起提供了代表线程池的接口：ExecutorService，常用的实现类：ThreadPoolExecutor
| ThreadPoolExecutor构造器 |
| public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) |
参数一：int corePoolSize：线程池的核心线程数量。
参数二：int maximumPoolSize：线程池的最大线程数量。
参数三：long keepAliveTime：临时线程的存活时间。
参数四：TimeUnit unit：临时线程存活的时间单位(秒，分，时，天)
参数五：BockingQueue<Runnable> workQueue：线程池的任务队列
参数六：ThreadFactory threadFactory：线程池的线程工厂
参数七：RejectedExecutionHandler handler：线程池的任务拒绝策略(线程都在忙，任务队列也满了的时候，新任务来了怎么处理)
| 拒绝策略 | 说明 |
| ThreadPoolExecutor.AbortPolicy | 丢弃任务并抛出RejectedExecutionException异常。默认 |
| ThreadPoolExecutor.DiscardPolicy | 丢弃任务，但不抛出异常；不推荐 |
| ThreadPoolExecutor.DiscardOldestPolicy | 抛弃队列中等待最久的任务，然后把当前任务加入队列中 |
| ThreadPoolExecutor.CallerRunsPolicy | 由主线程负责调用任务的run()方法从而绕过线程池直接执行 |
临时线程的创建：新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。
新任务拒绝：核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务
2. 使用线程池处理Runnable任务
| ExecutorService的常用方法名称 | 说明 |
| void execute(Runnable command) | 执行Runnable任务 |
| void shutdown() | 等全部任务执行完毕后，再关闭线程池 |
| List<Runnable> shutdownNow() | 立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务 |
public class MyRunnable implements Runnable {
//重写run方法
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "--子线程打印：qwer" );
try {
//测试：将睡眠时间调至最大 观察临时线程
Thread.sleep(Integer.MAX_VALUE);
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
/*
* public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
* long keepAliveTime, TimeUnit unit, BockingQueue<Runnable> workQueue,
* ThreadFactory threadFactory, RejectedExecutionHandler handler)
* */
ExecutorService pool = new ThreadPoolExecutor(3,5,8, TimeUnit.MINUTES,
new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
//void execute(Runnable command) 执行Runnable任务
Runnable r = new MyRunnable();
pool.execute(r);//创建一个新线程
pool.execute(r);//创建一个新线程
pool.execute(r);//创建一个新线程
pool.execute(r);//线程池的任务队列
pool.execute(r);//线程池的任务队列
pool.execute(r);//线程池的任务队列
pool.execute(r);//线程池的任务队列
pool.execute(r);//临时线程
pool.execute(r);//临时线程
//异常 RejectedExecutionException
pool.execute(r);
//void shutdown() 等全部任务执行完毕后，再关闭线程池
pool.shutdown();
//List<Runnable> shutdownNow() 立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务
pool.shutdownNow();
}3. 使用线程池处理Callable任务
| Future<T> submit(Callable<T> task) | 执行Callable任务，返回未来任务对象，用于获取线程返回的结果 |
public class MyCallable implements Callable<String> {
private int num;
public MyCallable(int num) {
this.num = num;
}
@Override
public String call() throws Exception {
int sum = 0;
for (int i = 0; i < num; i++) {
sum = sum + i;
}
return Thread.currentThread().getName() + "--线程sum:" + sum;
}
}
public static void main(String[] args) throws Exception {
/*
* public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
* long keepAliveTime, TimeUnit unit, BockingQueue<Runnable> workQueue,
* ThreadFactory threadFactory, RejectedExecutionHandler handler)
* */
ExecutorService pool = new ThreadPoolExecutor(3,5,8, TimeUnit.MINUTES,
new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
//Future<T> submit(Callable<T> task) 执行Callable任务，返回未来任务对象，用于获取线程返回的结果
Future<String> f1 = pool.submit(new MyCallable(10));
Future<String> f2 = pool.submit(new MyCallable(20));
Future<String> f3 = pool.submit(new MyCallable(30));
Future<String> f4 = pool.submit(new MyCallable(40));
Future<String> f5 = pool.submit(new MyCallable(50));
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是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象。
| 常用方法 | 说明 |
| public static ExecutorService newFixedThreadPool(int nThreads) | 创建固定数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代 |
| public static ExecutorService newSingleThreadExecutor() | 创建只要一个线程的线程池对象，如果该线程出现异常而结束，那么线程会补充一个新线程 |
| public static ExecutorService newCachedThreadPool() | 线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收 |
| public static ExecutorService ScheduledExecutorService newScheduledThreadPool(int corePoolSize) | 创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务 |
这些方法的底层，都是通过线程池的实现类对象ThreadPoolExecutor创建的线程池对象
public static void main(String[] args) {
//public static ExecutorService newFixedThreadPool(int nThreads) 创建固定数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代
ExecutorService pool = Executors.newFixedThreadPool(3);
//public static ExecutorService newSingleThreadExecutor() 创建只要一个线程的线程池对象，如果该线程出现异常而结束，那么线程会补充一个新线程
ExecutorService pool2 = Executors.newSingleThreadExecutor();
//public static ExecutorService newCachedThreadPool() 线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收
ExecutorService pool3 = Executors.newCachedThreadPool();
//public static ExecutorService ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务
ExecutorService pool4 = Executors.newScheduledThreadPool(3);
}计算密集型任务：核心线程数量=CPU的核数 + 1
IO密集型任务：核心线程数量=CPU的核数 + 2
5. Executors使用可能存在的陷阱
大型并发系统环境中使用Executors如果不注意可能会出现系统风险
八. 并发、并行、生命周期
1. 进程
进程：正在运行的程序(软件)就是一个独立的进程；线程是属于进程的，一个进程中可以同时运行多个线程；进程中的多个线程其实是并发和并行执行的
2. 并发
进程中的线程是由CPU负责调度执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，CPU会轮巡为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。
3. 并行
在同一时刻上，同时有多个线程在被CPU调度执行
多线程是并发和并行同时进行的
4. 线程的生命周期
线程从生到死的过程中，经历的各种状态及状态转换
Java线程的状态：6中状态定义在了Thread类内部枚举类中
public enum State {
//新建状态
NEW,
//可运行状态
RUNNABLE,
//锁 阻塞状态
BLOCKED,
//无限等待状态
WAITING,
//计时等待状态
TIMED_WAITING,
//被终止
TERMINATED;
}
| 线程状态 | 说明 |
| NEW (新建) | 线程刚被创建，但是并未启动 |
| Runnable(可运行) | 线程已经调用了start()，等待CPU调度 |
| Blocked(锁阻塞) | 线程在执行的时候未竞争到锁对象，该线程进入Blocked状态 |
| Waiting(无限等待) | 一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够用唤醒 |
| Timed Waiting(计时等待) | 同waiting状态，有几个方法(sleep，wait)有超时参数，调用他们则进入Timed Waiting(计时等待)状态 |
| Teminated(被终止) | 因为run方法正常退出而死亡，或者因为没有捕获的异常终止run方法而死亡 |
九. 悲观锁、乐观锁
1. 悲观锁：一上来就加锁，每次只能一个线程进入访问完毕后，在解锁。线程安全，性能较差
public class MyRunnable implements Runnable {
private int num;
//重写run方法
@Override
public void run() {
for (int i = 0; i < 10; i++) {
//悲观锁
synchronized (this) {
System.out.println(Thread.currentThread().getName() + ":" + ++num);
}
}
}
}
public static void main(String[] args) {
Runnable runnable = new MyRunnable();
//悲观锁
for (int i = 0; i < 10; i++) {
new Thread(runnable).start();
}
}2. 乐观锁：一开始不上锁，认为是没有问题的，等要出现线程安全问题的时候才开始控制。线程安全，性能较好。
public class MyRunnable2 implements Runnable {
/* private int num;*/
//整数修改的乐观锁 原子类实现
private AtomicInteger num = new AtomicInteger();
//重写run方法
@Override
public void run() {
for (int i = 0; i < 10; i++) {
//乐观锁
System.out.println(Thread.currentThread().getName() + ":" + num.incrementAndGet());
}
}
}
public static void main(String[] args) {
Runnable runnable = new MyRunnable2();
//乐观锁
for (int i = 0; i < 10; i++) {
new Thread(runnable).start();
}
}