6.多线程
6.1 多线程概念
进程是什么(process)
对一个程序的运行状态, 以及在运行中所占用的资源(内存, CPU)的描述;
一个进程可以理解为一个程序; 但是反之, 一个程序就是一个进程, 这句话是错的。
进程的特点:
- 独立性: 不同的进程之间是相互独立的, 相互之间资源不共享；
- 动态性: 进程在程序中不是静止不动的, 而是一直是活动状态；
- 并发性: 多个进程可以在一个处理器上同时运行, 互不影响；
线程是什么(thread)
是进程的一个组成部分, 一个进程中可以包含多个线程, 每一个线程都可以去处理一项任务；
进程在开辟的时候, 会自动的创建一个线程, 这个线程叫做 主线程；
一个进程包含多个线程, 且至少是一个, 如果一个进程中没有线程了, 这个进程会被终止；
多线程的执行是抢占式的, 多个线程在同一个进程中并发执行任务, 其实就是CPU快速的在不同的线程之间进行切换,
进程与线程的关系和区别
- 一个程序运行后, 至少有一个进程
- 一个进程包含多个线程, 至少一个线程
- 进程之间是资源不共享的, 但是线程之间是资源共享的
- 系统创建进程的时候, 需要为进程重新分配系统资源, 而创建线程则容易很多, 因此使用多线程在进行并发任务的时候, 效率比多进程高
区别并行和并发
并行：指在同一时刻，有多条指令在多个处理器上同时执行 ；
并发：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行；
6.2 创建线程的方式
继承Thread类
Thread是所有线程类的父类, 实现了对线程的抽取和封装；
使用继承Thread类实现多线程的步骤:
继承Thread类, 写一个Thread的子类
在子类中, 重写父类中的run方法, run方法就代表了这个线程需要处理的任务(希望这个线程处理什么任务, 就把这个任务写到run方法中), 因此, run方法也被称为 线程执行体
实例化这个子类对象, 即是开辟了一个线程
调用start方法, 来执行这个线程需要处理的任务(启动线程) ```java public class Demo01 { public static void main(String[] args) { //创建自定义线程对象 MyThread mt = new MyThread(“新的线程！”); //开启新线程 mt.start(); //在主方法中执行for循环 for (int i = 0; i < 10; i++) { System.out.println(“main线程！”+i); } } } //自定义线程类 public class MyThread extends Thread { //定义指定线程名称的构造方法 public MyThread(String name) { //调用父类的String参数的构造方法，指定线程的名称 super(name); } /**
- 重写run方法，完成该线程执行的逻辑 */ @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println(getName()+”：正在执行！”+i); } } } ```
实现Runnable接口
实现Runnable接口, 并创建线程的步骤:
设计一个类, 实现Runnable接口, 并重写接口中的run方法, 在run方法中, 写上这个线程要处理的任务
创建Runnable实现类的对象, 并把这个对象作为Thread的target进行Thread对象的实例化, 这个Thread对象才是真正的线程对象
调用start方法, 来启动线程
public class Demo02 {public static void main(String[] args) {//创建线程执行目标类对象Runnable runn = new MyRunnable();//将Runnable接口的子类对象作为参数传递给Thread类的构造函数Thread thread = new Thread(runn);Thread thread2 = new Thread(runn);//开启线程thread.start();thread2.start();for (int i = 0; i < 10; i++) {System.out.println("main线程：正在执行！"+i);}}}//自定义线程执行任务类public class MyRunnable implements Runnable{//定义线程要执行的run方法逻辑@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println("我的线程：正在执行！"+i);}}}
Callable
class CallableThreadDemo implements Callable<Integer> {public static void main(String[] args) throws ExecutionException, InterruptedException {CallableThreadTest ctt = new CallableThreadTest();FutureTask<Integer> ft = new FutureTask<>(ctt);new Thread(ft, "有返回值的线程").start();System.out.println("子线程的返回值" + ft.get());}@Overridepublic Integer call() {int i;for (i = 0; i < 10; i += 2) {System.out.println(Thread.currentThread().getName() + " " + i);}return i;}}
三种方式的不同点
实现Runnable接口的方式:
- 线程对应的任务类, 只是实现了Runnable接口, 不会对原有的继承关系产生影响
- 多个线程可以使用同一个Runnable接口实现类对象来实例化, 非常适合多个线程访问相同的资源情况
- 弊端:
- 编程稍微复杂, 不直观
- 如果需要获取到当前线程, 只能使用 Thread.currentThread() 来获取
继承Thread的方式:
- 编程简单, 直观,
- 如果需要访问当前线程, 直接用this即可, 也可以用 Thread.currentThread()
- 弊端:因为线程类继承自Thread类, 因此这个类不能再继承自其他类
实际上, 大多数需要用到多线程的情况, 都是使用的Runnable接口的方式来实现的 [推荐使用匿名内部类]
strart() 和 run() 的区别
start方法会开辟一个线程, 然后在这个新的线程中执行run中的逻辑
但是如果直接调用run(), 则表示需要在当前的线程中执行逻辑。
Runnable与Callable
相同点：都是接口，都可以编写多线程程序，都采用Thread.start()启动线程
不同点：Runnable没有返回值；Callable可以返回执行结果，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果
Callable接口的call()方法允许抛出异常；Runnable的run()方法异常只能在内部消化，不能往上继续抛
注：Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。
6.3 线程常用的方法
线程的名字
Thread thread = new Thread();// 设置线程的名字// 需要放到线程启动之前thread.setName(name);// 获取线程名字thread.getName();
线程休眠 sleep
让一个指定的线程, 释放CPU时间片, 进入阻塞状态
休眠时间结束后, 线程进入就绪状态, 开始争抢时间片
Thread.sleep(500): 时间单位是毫秒
会有一个InterruptedException异常
设置线程优先级 priority
可以通过设置线程的优先级, 来修改某一个线程抢到时间片的概率, 优先级越高的线程, 抢到CPU时间片的概率越高, 但是这不意味者, 优先级高的线程一定能抢到时间片
默认情况下, 每一个线程的优先级, 都与创建他的线程优先级相同
优先级的范围 [0,10], 新建的线程, 优先级默认是5.
设置线程的优先级, 需要在线程启动(start)之前
thread.setPriority(2);
合并线程 join
在一个线程执行的过程中, 如果遇到了其他线程需要合并进来, 此时这个线程会释放CPU时间片, 去执行合并进来的线程. 合并进来的线程执行结束后, 再执行原来的逻辑.
特点:
- 线程合并, 当前线程一定会释放CPU时间片, 优先执行合并进来的线程
- 哪个线程需要合并到当前线程中, 就在当前线程中, 添加要合并的线程
- 合并之前, 线程一定要处于start
后台线程
一个隐藏起来的, 一直默默地在后面执行的线程, 直到程序结束
又叫做 守护线程, 或者精灵线程,
JVM中的垃圾回收机制就是一个很典型的守护线程
如果所有的前台线程都死了, 后台线程会自动死亡
线程让步 yield
可以让当前的线程暂停, 但是不会进入阻塞, 只是从运行状态切换到了就绪状态, 完全可能出现的情况: 某一个线程yield暂停, 线程调度器又将其调度出来继续执行
实际上, 当某个线程使用yield让步后, 只有优先级与当前线程相同, 或者大于当前线程优先级的线程, 才有执行的机会
线程的生命周期
对于一个线程, 在被创建后, 不是立即就进入到了运行状态, 也不是一直处于运行状态, 在线程的声明周期中, 一个线程会在多种状态之间进行切换
new :创建 状态, 线程被实例化, 但是还没有开始执行(start)
runnable: 就绪状态, 已经执行过start, 线程已经启动了, 只是没有抢到CPU时间片
running: 运行状态, 抢到了CPU时间片
blocked: 阻塞状态, 线程执行的过程中, 遇到一些特殊情况, 会进入阻塞状态. 阻塞中的线程, 是不能参数时间片的抢夺的 (不能被线程调度器调度)
dead: 死亡状态, 线程终止
正常死亡 : run方法中的代码执行结束
非正常死亡 : 强制使用stop方法停止这个线程
6.4 线程安全
临界资源问题：由于线程之间是资源共享的。如果有多个线程，同时对一个数据进行操作，此时这个数据会出现问题。
如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
public class ThreadDemo {public static void main(String[] args) {//创建票对象Ticket ticket = new Ticket();//创建3个窗口Thread t1 = new Thread(ticket, "窗口1");Thread t2 = new Thread(ticket, "窗口2");Thread t3 = new Thread(ticket, "窗口3");t1.start();t2.start();t3.start();}}//模拟票class Ticket implements Runnable {//共5票int ticket = 5;@Overridepublic void run() {//模拟卖票while(true){if (ticket > 0) {//模拟选坐的操作try {Thread.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);}}}
如果有一个线程在访问一个临界资源，在访问之前，先对这个资源“上锁”，此时如果有其他的线程也需要访问这个临界资源，需要先查这个资源有没有被上锁，如果没有被上锁，此时这个线程可以访问这个资源；如果上锁了，则此时这个线程进入阻塞状态，等待解锁。
6.5 线程同步
同步代码段
// 同步代码段// 小括号：就是锁// 大括号：同步代码段，一般情况下，写需要对临界资源进行的操作synchronized () {}// 关于同步锁：可以分成两种：对象锁、类锁// 同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。
public class Ticket implements Runnable {//共10张票int ticket = 10;//定义锁对象Object lock = new Object();@Overridepublic void run() {//模拟卖票while(true){//同步代码块synchronized (lock){if (ticket > 0) {//模拟电影选坐的操作try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);}}}}}
同步方法
// 使用synchronized关键字修饰的方法就是同步方法// 将一个方法中所有的代码进行一个同步// 相当于将一个方法中所有的代码都放到一个synchronized代码段中// 同步方法的锁：// 1. 如果这个方法是一个非静态方法：锁是this// 2. 如果这个方法是一个静态方法：锁是类锁（当前类.class）private synchronized void sellTicket() {}
同步方法解决安全问题
public class Ticket implements Runnable {//共100票int ticket = 100;//定义锁对象Object lock = new Object();@Overridepublic void run() {//模拟卖票while(true){//同步方法method();}}//同步方法,锁对象thispublic synchronized void method(){if (ticket > 0) {//模拟选坐的操作try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);}}}
lock与unlock
就是一个类RenntrantLock
public class Ticket implements Runnable {//共10票int ticket = 10;//创建Lock锁对象Lock ck = new ReentrantLock();@Overridepublic void run() {//模拟卖票while(true){//synchronized (lock){ck.lock();if (ticket > 0) {//模拟选坐的操作try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);}ck.unlock();//}}}}
公平锁：谁等的时间最长的线程，优先获取锁
public class Ticket implements Runnable {//共10票int ticket = 10;//创建Lock锁对象Lock ck = new ReentrantLock(true);@Overridepublic void run() {//模拟卖票while(true){//synchronized (lock){ck.lock();if (ticket > 0) {//模拟选坐的操作try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);}ck.unlock();//}}}}
等待唤醒机制
多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。
wait() 、notify() 、notifyAll()
wait(): 等待。使得当前的线程释放锁标记，进入等待队列。可以使当前的线程进入阻塞状态。
notify(): 唤醒，唤醒等待队列中的一个线程。
notifyAll(): 唤醒，唤醒等待队列中所有的线程。
wait和sleep的区别:
- 两个方法都可以使一个线程进入阻塞。
- 区别：wait方法会释放锁标记，sleep则不会释放锁标记。
package kaikeba;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class ThreadDemo{public static void main(String[] args) {ResourceUnit r = new ResourceUnit();Producer p1 = new Producer(r, 1);Consumer c1 = new Consumer(r, 1);p1.start();c1.start();}}class ResourceUnit {private int contents;private boolean available = false;public synchronized int get() {while (available == false) {try {wait();}catch (InterruptedException e) {}}available = false;notifyAll();return contents;}public synchronized void put(int value) {while (available == true) {try {wait();}catch (InterruptedException e) {}}contents = value;available = true;notifyAll();}}class Consumer extends Thread {private ResourceUnit resourceUnit;private int number;public Consumer(ResourceUnit r, int number) {resourceUnit = r;this.number = number;}public void run() {int value = 0;for (int i = 0; i < 10; i++) {value = resourceUnit.get();System.out.println("消费者 #" + this.number+ " got: " + value);}}}class Producer extends Thread {private ResourceUnit resourceUnit;private int number;public Producer(ResourceUnit r, int number) {resourceUnit = r;this.number = number;}public void run() {for (int i = 0; i < 10; i++) {resourceUnit.put(i);System.out.println("生产者 #" + this.number + " put: " + i);try {sleep((int)(Math.random() * 100));} catch (InterruptedException e) { }}}}
线程死锁(了解)
在解决临界资源问题的时候，我们引入了一个”锁”的概念。我们可以用锁对一个资源进行保护。实际，在多线程的环境下，有可能会出现一种情况：
假设有A和B两个线程，其中线程A持有锁标记a，线程B持有锁标记b，而此时，线程A等待锁标记b的释放，线程B等待锁标记a的释放。这种情况，叫做死锁。
6.6 线程池
线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
创建并使用线程池
通常，线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。
Executors：线程池创建工厂类
public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象
ExecutorService：线程池类
Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行
Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用
public static void main(String[] args) {ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);for (int i = 0; i < 10; i++) {final int index = i;fixedThreadPool.execute(new Runnable() {@Overridepublic void run() {try {System.out.println(index);Thread.sleep(2000);System.out.println(Thread.currentThread().getName());} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}});}}
若有收获，就点个赞吧
0 人点赞
