1. 概述
- 多线程是指从软件或硬件上实现多个线程并发执行的技术
- 线程是CPU调度和执行的单位，其从属于进程
- 进程是执行程序的一次执行过程，是系统资源分配的单位
- 一个进程一般包含多个线程，其至少也要包含一个线程
2. 实现多线程
2.1 继承Thread类
-
Thread类是Java中的一个线程类，继承了Thread类就可以实现多线程
-
继承了Thread类就必须要重写它下面的run()方法
-
创建线程对象后调用start()方法启动线程
// 继承Thread类实现多线程 public class ThreadDemo01_ExtendsThread extends Thread { // 重写run()方法 @Override public void run() { for (int i = 1; i <= 200; i++) { System.out.println("run()正在执行第"+i+"次"); } } public static void main(String[] args) { ThreadDemo01_ExtendsThread t1 = new ThreadDemo01_ExtendsThread(); t1.start(); for (int i = 1; i <= 200; i++) { System.out.println("main()正在执行第"+i+"次"); } } }
2.2 实现Runnable接口（推荐）
-
Runnable接口是Java中实现多线程的接口，Thread类也实现了Runnable接口
-
实现Runnable接口需要重写它下面的run()方法
-
通过Thread类间接创建线程对象，调用start()方法启动线程
// 继承Runnable接口实现多线程 public class ThreadDemo02_ImplementsRunnable implements Runnable { // 重写run()方法 @Override public void run() { for (int i = 1; i <= 100; i++) { System.out.println(Thread.currentThread().getName()+"正在执行第"+i+"次"); } } public static void main(String[] args) { new Thread(new ThreadDemo02_ImplementsRunnable(),"t1").start(); new Thread(new ThreadDemo02_ImplementsRunnable(),"t2").start(); new Thread(new ThreadDemo02_ImplementsRunnable(),"t3").start(); } }
2.3 实现Callable接口
-
Callable接口是一个有返回值的实现多线程的接口
-
实现Runnable接口需要重写它下面的call()方法
-
通过Callable接口实现多线程的一般步骤：
- 创建目标对象
- 创建执行服务
- 提交执行
- 获取结果
- 关闭服务
import java.util.concurrent.*; // 继承Callable接口实现多线程 public class ThreadDemo03_ImplementsCallable implements Callable<Boolean> { @Override public Boolean call() throws Exception { for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName()+"正在执行第"+i+"次"); } return true; } public static void main(String[] args) throws ExecutionException, InterruptedException { // 实例化对象 ThreadDemo03_ImplementsCallable t1 = new ThreadDemo03_ImplementsCallable(); ThreadDemo03_ImplementsCallable t2 = new ThreadDemo03_ImplementsCallable(); ThreadDemo03_ImplementsCallable t3 = new ThreadDemo03_ImplementsCallable(); // 创建执行服务 ExecutorService ser = Executors.newFixedThreadPool(3); // 提交执行 Future<Boolean> r1 = ser.submit(t1); Future<Boolean> r2 = ser.submit(t2); Future<Boolean> r3 = ser.submit(t3); // 获取结果 boolean rs1 = r1.get(); boolean rs2 = r2.get(); boolean rs3 = r3.get(); // 关闭服务 ser.shutdown(); } }
2.4 认识多线程的并发问题
-
多个线程访问同一个对象时，会出现并发问题，其实质就是内存访问的线程调度问题
-
一个买票代码案例：
// 售票机 class TicketMachine implements Runnable { private int tickets; // 剩余票数 public TicketMachine(int tickets) { this.tickets = tickets; } @Override public void run() { while (this.tickets > 0) { System.out.println(Thread.currentThread().getName() + "拿到了第" + this.tickets-- + "张票，剩余" + this.tickets + "张"); try { Thread.sleep(200); // 模拟延时 } catch (InterruptedException e) { e.printStackTrace(); } } } } public class BuyTicketDemo01 { public static void main(String[] args) { // 创建售票机 TicketMachine tm = new TicketMachine(10); new Thread(tm,"小明").start(); new Thread(tm,"小红").start(); new Thread(tm,"小王").start(); /* 可能结果： 小明拿到了第10张票，剩余9张 小红拿到了第9张票，剩余8张 小王拿到了第8张票，剩余7张 小红拿到了第7张票，剩余5张 小王拿到了第5张票，剩余4张 小明拿到了第6张票，剩余5张 小红拿到了第3张票，剩余1张 小王拿到了第4张票，剩余3张 小明拿到了第2张票，剩余1张 小王拿到了第1张票，剩余0张 小明拿到了第1张票，剩余0张 （票数出现错误，后面线程同步解决） */ } }
3. sleep()线程休眠
-
sleep()是多线程的休眠方法，它能让当前线程阻塞指定时间
-
sleep()方法有一个毫秒的传入参数(1秒=1000毫秒)
-
sleep()执行结束后，线程进入就绪状态
-
sleep()可以模拟网络延时(用于测试中放大错误的发生性)、倒计时等
-
sleep()不会释放锁
// Thread.sleep()模拟延时、倒计时 public class ThreadDemo04_Sleep implements Runnable { @Override public void run() { // 等待5秒 for (int i = 5; i > 0; i--) { System.out.println("请等待"+i+"秒..."); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("等待结束！"); } public static void main(String[] args) { ThreadDemo04_Sleep t1 = new ThreadDemo04_Sleep(); new Thread(t1).start(); } }
4. ~~stop()~~线程停止
-
stop()、destroy()方法可以停止线程，但不推荐已经废弃了
-
线程停止一般让线程自已停止
-
建议使用标志位法停止线程
// 线程停止（标志位法） public class ThreadDemo05_Stop implements Runnable { private boolean flag = true; // 标志位 @Override public void run() { int i = 1; while (flag) { System.out.println("run()正在运行..."+i++); } System.out.println("run()停止运行"); } public void stop() { this.flag = false; } public static void main(String[] args) { ThreadDemo05_Stop t1 = new ThreadDemo05_Stop(); new Thread(t1).start(); for (int i = 0; i < 500; i++) { if(i == 250) { t1.stop(); } System.out.println("main()正在运行..."+i); } } }
5. yield()线程礼让
-
yield()是多线程的礼让方法，它能让cpu重新调度，但不一定礼让成功
-
yield()执行结束后，线程进入就绪状态
// Thread.yield()礼让方法 public class ThreadDemo06_Yield implements Runnable { @Override public void run() { System.out.println(Thread.currentThread().getName()+"开始执行~~~"); Thread.yield(); // 礼让方法，让cpu重新调度 System.out.println(Thread.currentThread().getName()+"结束执行~~~"); } public static void main(String[] args) { new Thread(new ThreadDemo06_Yield(),"a").start(); new Thread(new ThreadDemo06_Yield(),"b").start(); System.out.println("结束"); /* 可能结果： a开始执行~~~ b开始执行~~~ b结束执行~~~ a结束执行~~~ 结束 */ } }
6. join()线程强制执行
-
join()是多线程的强制执行的方法，它能强制执行调用join()方法的线程并阻塞其他线程，直到该线程执行结束
// join()强制执行方法 public class ThreadDemo07_Join implements Runnable { @Override public void run() { for (int i = 1; i <= 1000; i++) { System.out.println("run()执行中~~~"+i); } } public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(new ThreadDemo07_Join()); thread.start(); for (int i = 1; i <= 500; i++) { System.out.println("main()执行中~~~"+i); if(i==100) { thread.join(); // 强制执行thread线程 } } } }
7. getState()观察线程的状态
-
getState()是多线程获取线程状态方法，其返回值为Thread.State类型
-
在Java中，线程一共有初始(NEW)、 运行(RUNNABLE)、阻塞(BLOCKED)、 等待(WAITING)、超时等待(TIMED_WAITING)和终止(TERMINATED)六种状态：
- 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法
- 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
- 阻塞(BLOCKED)：表示线程阻塞于锁。
- 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
- 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
// 观察线程的状态 public class ThreadDemo08_Status { public static void main(String[] args) throws InterruptedException { Thread.State state; // 线程的状态 // 创建线程 Thread thread = new Thread(() -> { System.out.println("正在执行~~~"); try { Thread.sleep(1000); // 阻塞线程 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("执行结束~~~"); }); state = thread.getState(); System.out.println(state); // 启动线程 thread.start(); state = thread.getState(); System.out.println(state); // 执行线程 while (thread.getState()!=Thread.State.TERMINATED) { state = thread.getState(); System.out.println(state); Thread.sleep(500); } // 线程结束 state = thread.getState(); System.out.println(state); /* 结果： NEW RUNNABLE RUNNABLE 正在执行~~~ TIMED_WAITING 执行结束~~~ TERMINATED */ } }
8. Priority线程的优先级
-
在Java中，线程的执行由一个线程调度器根据线程的优先级来决定，优先级高的线程大概率先执行
-
线程的优先级范围为：1~10
-
线程通过getPriority()方法来获取线程的优先级，其返回值为int类型
-
线程通过setPriority(xxx)方法来获取线程的优先级，其参数值为int类型
// 线程的优先级 public class ThreadDemo09_Priority implements Runnable { public static void main(String[] args) { Thread t1 = new Thread(new ThreadDemo09_Priority()); Thread t2 = new Thread(new ThreadDemo09_Priority()); Thread t3 = new Thread(new ThreadDemo09_Priority()); Thread t4 = new Thread(new ThreadDemo09_Priority()); Thread t5 = new Thread(new ThreadDemo09_Priority()); // 先设置优先级再启动 t1.start(); // 不设置优先级默认为5 t2.setPriority(1); t2.start(); t3.setPriority(3); t3.start(); t4.setPriority(7); t4.start(); t5.setPriority(10); t5.start(); System.out.println("结束"); /* 结果： Thread-4-->10 Thread-3-->7 Thread-0-->5 Thread-2-->3 Thread-1-->1 结束 */ } @Override public void run() { System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority()); } }
9. daemon守护线程
-
线程分为用户线程和守护线程
-
Java虚拟机必须等待用户线程执行完毕
-
Java虚拟机不用等待守护线程执行完毕
-
通过setDaemon(true)方法将线程设置为守护线程
// 守护线程 class God implements Runnable { @Override public void run() { while (true) { System.out.println("上帝守护着你~~~"); } } } // 用户线程 class You implements Runnable { @Override public void run() { for (int i = 0; i < 36500; i++) { System.out.println("你开心的活着~~~"); } System.out.println("再见，世界！"); } } public class ThreadDemo10_Daemon{ public static void main(String[] args) { // 创建线程 Thread god = new Thread(new God()); Thread you = new Thread(new You()); // 设置Daemon，成为守护线程 god.setDaemon(true); // Daemon默认为false // 启动线程 god.start(); you.start(); } }
10. Synchronized线程同步
-
synchronized是线程同步的关键字(隐式的锁)，它能够让多个线程操作同一对象(并发)时按顺序执行(按顺序获取锁)
-
在Java中，一个对象对应一个锁，获得锁的线程才能操作锁对应的对象
-
synchronized能修饰方法使方法成为同步方法，默认锁this对象
-
synchronized[(Object)]能修饰代码块使代码块成为同步方法块，Object为被锁的对象
// 椅子 class Chair implements Runnable { // 同步方法 @Override public synchronized void run() { for (int i = 0; i < 1000; i++) { System.out.println(Thread.currentThread().getName()+"正在椅子上休息~~~"+i); } System.out.println(Thread.currentThread().getName()+"休息结束！"); } /* // 同步代码块 @Override public void run() { synchronized (this) { for (int i = 0; i < 1000; i++) { System.out.println(Thread.currentThread().getName()+"正在椅子上休息~~~"+i); } System.out.println(Thread.currentThread().getName()+"休息结束！"); } } */ } // 线程同步机制synchronized，隐式的锁 public class ThreadDemo11_Synchronized { public static void main(String[] args) { // 创建启动线程 Chair chair = new Chair(); new Thread(chair,"小明").start(); new Thread(chair,"小红").start(); } } -
解决2.4中买票的并发问题
// 售票机 class TicketMachine2 implements Runnable { private int tickets; // 剩余票数 public TicketMachine2(int tickets) { this.tickets = tickets; } @Override public void run() { while (this.tickets > 0) { synchronized (this) { // 同步块监视this对象 System.out.println(Thread.currentThread().getName() + "拿到了第" + this.tickets-- + "张票，剩余" + this.tickets + "张"); } try { Thread.sleep(200); // 模拟延时 } catch (InterruptedException e) { e.printStackTrace(); } } } } public class BuyTicketDemo02_Synchronized { public static void main(String[] args) { // 创建售票机 TicketMachine2 tm = new TicketMachine2(10); new Thread(tm,"小明").start(); new Thread(tm,"小红").start(); new Thread(tm,"小王").start(); /* 可能结果： 小明拿到了第10张票，剩余9张 小王拿到了第9张票，剩余8张 小红拿到了第8张票，剩余7张 小王拿到了第7张票，剩余6张 小明拿到了第6张票，剩余5张 小红拿到了第5张票，剩余4张 小明拿到了第4张票，剩余3张 小王拿到了第3张票，剩余2张 小红拿到了第2张票，剩余1张 小红拿到了第1张票，剩余0张 */ } }
11. DeadLock死锁
-
一个同步块需要同时拥有“两把以上的锁”时，可能造成死锁，例如：同一时间下，线程1拥有A锁，线程2拥有B锁。之后，线程1在拿着A锁的的情况下想获取B锁，线程2在拿着B锁的的情况下想获取A锁，这样就会造成死锁，程序会僵持不动。
// 第一根筷子 class FirstChopsticks {} // 第二根筷子 class SecondChopsticks {} // 吃饭 class EatMeals implements Runnable { private FirstChopsticks firstChopsticks; // 第一根筷子 private SecondChopsticks secondChopsticks; // 第二根筷子 public EatMeals(FirstChopsticks firstChopsticks, SecondChopsticks secondChopsticks) { this.firstChopsticks = firstChopsticks; this.secondChopsticks = secondChopsticks; } @Override public void run() { if(Thread.currentThread().getName().equals("小明")) { synchronized (this.firstChopsticks) { try { Thread.sleep(1000); // 保证同时进入线程 } catch (InterruptedException e) { e.printStackTrace(); } synchronized (this.secondChopsticks) { System.out.println(Thread.currentThread().getName()+"开始吃饭"); } } }else { synchronized (this.secondChopsticks) { try { Thread.sleep(1500); // 保证同时进入线程 } catch (InterruptedException e) { e.printStackTrace(); } synchronized (this.firstChopsticks) { System.out.println(Thread.currentThread().getName()+"开始吃饭"); } } } System.out.println(Thread.currentThread().getName()+"吃完了~~~"); } } // 死锁 public class ThreadDemo12_DeadLock { public static void main(String[] args) { // 创建开启线程 EatMeals eatMeals = new EatMeals(new FirstChopsticks(),new SecondChopsticks()); new Thread(eatMeals,"小明").start(); new Thread(eatMeals,"小红").start(); /* 结果： （产生死锁，程序僵持不停） （解决方法：if(Thread.currentThread().getName().equals("小明")) { synchronized (this.firstChopsticks) { try { Thread.sleep(1000); // 保证同时进入线程 } catch (InterruptedException e) { e.printStackTrace(); } } synchronized (this.secondChopsticks) { System.out.println(Thread.currentThread().getName()+"开始吃饭"); } }else { synchronized (this.secondChopsticks) { try { Thread.sleep(1500); // 保证同时进入线程 } catch (InterruptedException e) { e.printStackTrace(); } } synchronized (this.firstChopsticks) { System.out.println(Thread.currentThread().getName()+"开始吃饭"); } }） */ } }
12. Lock锁
-
在Java中，可以显式的定义Lock锁，其实现类一般用ReentrantLock(可重入锁)
import java.util.concurrent.locks.ReentrantLock; // 椅子 class Chair2 implements Runnable { private final ReentrantLock lock = new ReentrantLock(); // 可重入锁 @Override public void run() { lock.lock(); // 关锁 for (int i = 0; i < 1000; i++) { System.out.println(Thread.currentThread().getName()+"正在椅子上休息~~~"+i); } System.out.println(Thread.currentThread().getName()+"休息结束！"); lock.unlock(); // 解锁 } } // Lock锁，显式的锁 public class ThreadDemo13_Lock { public static void main(String[] args) { // 创建启动线程 Chair2 chair2 = new Chair2(); new Thread(chair2,"小明").start(); new Thread(chair2,"小红").start(); } }
13. 线程池
-
线程池是多线程处理的一种形式，它在进程开始的时候就创建一定数量的线程，并将这些线程添加到线程池中等待工作
-
线程池具有以下优点：
- 提高响应速度：用现有线程服务请求比等待创建一个线程更快
- 降低资源消耗：重复利用现有的线程，不需要每次都创建浪费资源
- 便于线程管理：
- 自定义核心池的大小：corePoolSize
- 自定义最大线程数：maxmumPoolSize
- 自定义线程的持续时间：keepAliveTime
-
创建线程池及服务：ExecutorService ser = Executors.newFixedThreadPool(线程数);
-
执行任务：
- void execute(Runnable command)：执行任务/命令，没有返回值，一般用于执行Runnable
- <T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般用于执行Callable
-
关闭连接池：void shutdown();
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; class SayName implements Runnable { @Override public void run() { System.out.println(Thread.currentThread().getName()); } } // 线程池 public class ThreadDemo14_Pool { public static void main(String[] args) { // 创建服务、线程池 ExecutorService ser = Executors.newFixedThreadPool(5); // 执行线程 SayName sayName = new SayName(); ser.execute(sayName); ser.execute(sayName); ser.execute(new SayName()); ser.execute(new SayName()); // 关闭连接 ser.shutdown(); /* 可能结果： pool-1-thread-1 pool-1-thread-3 pool-1-thread-2 pool-1-thread-4 */ } }
扫一扫
3812
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
