多线程
一、多线程
1、进程与线程
进程：
是一个正在运行的程序。如：一个App。
是系统进行资源分配和调用的独立单位
每个进程都有它自己的空间和系统资源。
线程：
是系统中的单个顺序控制流，是一条执行路径。如：App中的多种可运行的功能。360的体检，杀毒，清理垃圾等都是多个线程。
单线程：一个进程如果只有一条执行路径，则称为单线程程序
多线程：一个进程如果有多条执行路径，则称为多线程程序
2、并发与并行
并发：
在同一时刻，有多个指令在单个CPU上交替执行。如：一个厨师炒多个菜（这里炒一下那里炒一下）。
并行：
在同一时刻，有多个指令在多个CPU上同时执行。如：多个厨师一起炒多个菜。
3、实现线程的三种方式
方法介绍
| 方法名 | 说明 |
|---|---|
| void run() | 在线程开始前，此方法将被调用执行（线程开启所要执行的代码） |
| void start() | 开始执行线程的代码，Java虚拟机将会去调用重写后的run()方法 |
1）继承Thread类重写run()方法
实现步骤：
-
定义一个线程类继承Thread类
-
重写run()方法
-
创建线程类对象
-
调用start()方法启动线程
代码演示：
//线程类 public class Thread01 extends Thread { //定义一个线程类继承Thread类 @Override public void run() { //重写run()方法 for (int i = 0; i < 100; i++) { System.out.println(i); } } } //测试类 public class TDemo01 { public static void main(String[] args) { Thread01 t1 = new Thread01(); //创建线程类对象 t1.start(); //调用start()方法启动线程 Thread01 t2 = new Thread01(); //创建线程类对象 t2.start(); //调用start()方法启动线程 } }两个小问题
-
为什么要重写run()方法？
因为run()是用来封装被线程执行的代码
-
run()方法和start()方法的区别？
run()：封装线程执行的代码，直接调用，相当于普通方法的调用
start()：启动线程；然后由JVM调用此线程的run()方法
-
2）实现Runnable接口重写run()方法
实现步骤：
-
定义一个线程类实现Runnable接口
-
重写run()方法
-
创建线程类对象
-
创建Thread类对象把线程类对象作为构造方法的参数传入
-
用Thread类对象调用start()方法启动线程
代码演示：
//线程类 public class Runnable01 implements Runnable { //定义一个线程类实现Runnable接口 @Override public void run() { //重写run()方法 for (int i = 0; i < 1000; i++) { System.out.println(i); } } } //测试类 public class RDemo01 { public static void main(String[] args) { Runnable01 r1 = new Runnable01(); //创建线程类对象 Thread t1 = new Thread(r1); //创建Thread类对象把线程类对象作为构造方法的参数传入 t1.start(); //用Thread类对象调用start()方法启动线程 Runnable01 r2 = new Runnable01(); //创建线程类对象 Thread t2 = new Thread(r2); //创建Thread类对象把线程类对象作为构造方法的参数传入 t2.start(); //用Thread类对象调用start()方法启动线程 } }-
多线程的实现方案有两种
- 继承Thread类
- 实现Runnable接口
-
相比继承Thread类，实现Runnable接口的好处
-
避免了Java单继承的局限性
-
适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想
-
-
3）实现Callable接口重写call()方法(不推荐)
特点：有返回值。用get()方法可获取返回值。
-
定义一个线程类实现Callable接口
-
重写call()方法
-
创建线程类对象
-
创建FutureTask类对象(泛型是返回值类型)把线程类对象作为构造方法的参数传入
-
创建Thread类对象把FutureTask类对象作为构造方法的参数传入
-
用Thread类对象调用start()方法启动线程
代码演示：
//线程类 public class Callable01 implements Callable { //定义一个线程类实现Callable接口 @Override public Object call() throws Exception { //重写call()方法 for (int i = 0; i < 1000; i++) { System.out.println(i); } return "运行完返回"; //定义返回值 } } //测试类 public class CDemo01 { public static void main(String[] args) throws ExecutionException, InterruptedException { Callable01 c1 = new Callable01(); //创建线程类对象 FutureTask<String> f1 = new FutureTask<String>(c1); //创建FutureTask类对象(泛型是返回值类型)把线程类对象作为构造方法的参数传入 Thread t1 = new Thread(f1); //创建Thread类对象把FutureTask类对象作为构造方法的参数传入 t1.start(); //用Thread类对象调用start()方法启动线程 Callable01 c2 = new Callable01(); FutureTask<String> f2 = new FutureTask<String>(c2); Thread t2 = new Thread(f2); t2.start(); String s = f2.get(); System.out.println(s); } }
4、线程的优先级
-
线程调度
-
两种调度方式
- 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
- 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些
-
Java使用的是抢占式调度模型
-
随机性
假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的
-
-
优先级相关方法
方法名 说明 final int getPriority() 返回此线程的优先级 final void setPriority(int newPriority) 更改此线程的优先级 线程默认优先级是5；线程优先级的范围是：1-10
5、线程控制的方法
相关方法
| 方法名 | 说明 |
|---|---|
| static void sleep(long millis) | 使当前正在执行的线程停留（暂停执行）指定的毫秒数（睡眠过程中不会释放锁） |
| void join() | 等待这个线程死亡 |
| void wait() | 线程等待（等待过程中会释放锁） |
| void notify() | 线程随机唤醒（随机唤醒该锁对象上的任意一个等待线程） |
| void notifyAll() | 线程全部唤醒（唤醒该锁对象上的所有等待线程） |
其他方法
| 方法名 | 说明 |
|---|---|
| Thread.currentThread().getName | 获取当前线程对象的名称 |
| void setName() | 设置名称 |
6、守护线程
为主线程存在，当主线程死亡守护线程也就没有存在的必要了。如：QQ聊天软件退出后，守护线程聊天窗口，空间动态等正在运行的线程也就跟着死亡了。
| 方法名 | 说明 |
|---|---|
| void setDaemon(boolean on) | 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出 |
//线程类
public class ThreadDaemon extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + ":" + i);
}
}
}
//测试类
public class ThreadDaemonDemo {
public static void main(String[] args) {
ThreadDaemon td1 = new ThreadDaemon();
ThreadDaemon td2 = new ThreadDaemon();
td1.setName("关羽");
td2.setName("张飞");
//设置主线程为刘备
Thread.currentThread().setName("刘备");
//设置守护线程
td1.setDaemon(true);
td2.setDaemon(true);
td1.start(); //开启一条线程，会自动调用run()方法
td2.start(); //开启一条线程，会自动调用run()方法
for(int i=0; i<10; i++) { //当主线程运行完10次之后守护线程就会跟着中断不会再执行
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
7、线程的生命周期
二、线程同步
1、买票案例
//线程任务类
public class TicktTset implements Runnable{
private static int titck=100;
@Override
public void run() {
while (true){
if (titck<=0){
break;
}else {
try {
Thread.sleep(300); //出票往往有一定的延迟（模拟延时）
} catch (InterruptedException e) {
e.printStackTrace();
}
titck--;
System.out.println(Thread.currentThread().getName()+"当前已卖出"+titck+"张票");
}
}
}
}
//测试类
public class Demo {
public static void main(String[] args) {
TicktTset ticktTset = new TicktTset();
Thread t1 = new Thread(ticktTset);
Thread t2 = new Thread(ticktTset);
Thread t3 = new Thread(ticktTset);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
结果显示出现了负号票和重复的票
2、线程不安全的原因
原因分析：
创建了三条线程，线程运行是由CPU随机调度的，线程运行到每行代码都有可能被其他线程抢到执行权。当绿箭头运行到ticket–时总数量为99，这时执行权被其他线程抢走，当其他也运行到ticket–时，总数量就编程98了，这样数量就剩98,第99张票就没了，这就造成了数据安全问题。（当多条线程运行代码时，不同线程执行相同代码共同代码，共享数据被修改，造成数据丢失）
3、同步代码块
解决方法：
在要执行的代码前加一把锁，让多条线程执行代码时，只有一条代码能够运行其中代码，其他线程只能在外面等待，第一条线程执行完后，才轮到其他线程执行。
这个锁就是同步代码块：锁多条语句操作共享数据，可以使用同步代码块实现
格式：
synchronized(){
多条语句操作共享数据代码
}
默认情况下，琐是打开的，只要一个线程进去执行代码了，锁就会关闭。
同步的好处和弊端：
优点：解决了多线程的数据安全问题。
弊端：当线程很多时，每位每个线程都会去判断同步上的锁，这是很耗费资源的，无形中降低了运行效率。
加锁后的代码：
public class TicktTset implements Runnable{
private static int titck=100;
@Override
public void run() {
while (true){
synchronized (this) { //小括号中的是锁对象 this表示当前类的对象TicktTset，多个线程必须使用同一把锁
if (titck <= 0) {
break;
} else {
try {
Thread.sleep(300); //出票往往有一定的延迟（模拟延时）
} catch (InterruptedException e) {
e.printStackTrace();
}
titck--;
System.out.println(Thread.currentThread().getName() + "当前已卖出" + titck + "张票");
}
}
}
}
}
4、同步方法
就是把synchronized关键字加在方法上
格式：修饰符 synchronized 返回值类型 方法名(方法参数){ }
同步代码块和同步方法的区别：
- 同步代码块锁住的是指定代码，同步方法锁住方法中所有代码。
- 同步代码块可以指定锁对象，不同方法不能指定锁对象。同步方法的锁对象是this
5、Lock锁
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock。
Lock实现提供比使用synchronized方法和语句更加广泛的锁定操作。
Lock中提供了获得锁和释放锁的方法
-
void lock()：获得锁
-
voud unlock() : 释放锁
Lock是一个接口，不能实例化，可采用他的实现类ReentrantLock来实例化
public class TicktTset implements Runnable{ private static int titck=100; private ReentrantLock lock = new ReentrantLock(); //获得锁对象 @Override public void run() { while (true){ // synchronized (this) { //小括号中的是锁对象 this表示当前类的对象TicktTset lock.lock(); //加锁 if (titck <= 0) { break; } else { try { Thread.sleep(300); //出票往往有一定的延迟（模拟延时） } catch (InterruptedException e) { e.printStackTrace(); } titck--; System.out.println(Thread.currentThread().getName() + "当前已卖出" + titck + "张票"); } // } lock.unlock();//释放锁 } } }
6、死锁问题（锁嵌套）
线程死锁是指由两个或者多个互相持有对方所需要的资源，导致这些线程都处于等待状态，无法继续执行下面代码。
三、生产者与消费者
1、生产者与消费者模型（等待唤醒机制）
生产者与消费者模式是一个非常经典的多线程协作模式。
| 方法名 | 说明 |
|---|---|
| void wait() | 无限等待状态 |
| void notifyAll() | 全部唤醒状态 |
2、经典案例代码
//生产者
public class Productor implements Runnable {
private Desk desk;
public Productor(Desk desk) {
this.desk = desk;
}
@Override
public void run() {
while (true){
synchronized (desk.getLock()){ //获取锁对象加锁
if (desk.getCount()==0){ //获取总数量当数量为0时，跳出
break;
}else if (!desk.isFlag()){ //判断桌子上的汉堡包还有没，没有就制作
System.out.println("生产中------");
desk.setFlag(true); //做完后桌子上标记为有汉堡包了
desk.getLock().notifyAll();//唤醒消费者者
}else {
try {
desk.getLock().wait(); //判断桌子上的汉堡包还有没，还有就等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
//桌子类（中间类）
public class Desk {
private int count=10; //汉堡包总数量
private boolean flag = true; //标记 判断桌子上是否还有汉堡包
private Object lock = new Object(); //锁对象
@Override
public String toString() {
return "Desk{" +
"count=" + count +
", flag=" + flag +
", lock=" + lock +
'}';
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
public Object getLock() {
return lock;
}
public void setLock(Object lock) {
this.lock = lock;
}
public Desk(int count, boolean flag, Object lock) {
this.count = count;
this.flag = flag;
this.lock = lock;
}
public Desk() {
}
}
//消费者
public class Foodier implements Runnable{
private Desk desk;
public Foodier(Desk desk) {
this.desk = desk;
}
@Override
public void run() {
while (true){
synchronized (desk.getLock()){ //获取锁对象加锁
if (desk.getCount()==0){ //获取总数量当数量为0时，跳出
break;
}else if (desk.isFlag()){ //判断桌子上的汉堡包做好了没,做好了就开吃
System.out.println("消费者正在吃!!!");
desk.setCount(desk.getCount()-1); //吃完了一个数量-1并重新赋值
desk.setFlag(false); //吃完后桌子上标记为没有汉堡包了
desk.getLock().notifyAll(); //唤醒生产者
}else {
try {
desk.getLock().wait(); //判断桌子上的汉堡包做好了没，没做好就等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
//测试类
public class Demo {
public static void main(String[] args) {
Desk desk = new Desk();
Foodier foodier = new Foodier(desk);
Productor productor = new Productor(desk);
Thread t1 = new Thread(foodier);
Thread t2 = new Thread(productor);
t1.start();
t2.start();
}
}
3、阻塞队列
BlockingQueue的核心方法:
-
put(anObject)：将参数放入队列，如果放不进会堵塞。
-
take()：取出第一个数据，去布袋就会堵塞。
案例演示：
阻塞队列实现等待唤醒机制：
一直制作一直取
101
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
