目录
一、多线程基础
概述
从软件或者硬件上实现多个线程并发执行的技术。 具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能
并发和并行
并行 : 在同一时刻，有多个指令在多个cpu上同时执行（需要硬件的支持）
并发 : 在同一时刻，有多个指令在单个CPU上交替执行
进程和线程
进程 : 正在运行的程序
独立性 : 进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位（最小）
动态性 : 进程的实质是程序的一次执行过程，进程是动态产生，动态消亡
并发性 : 任何进程都可以同其它进程一起并发执行线程 : 是进程中的单个顺序控制流，是一条执行路径
单线程 : 一个进程如果只有一条执行路径，则称为单线程
多线程 : 一个进程如果有多条执行路径，则称为多线程
二、多线程的实现
-
继承Thread类
-
实现Runnable接口
-
实现Callable'接口
Thread线程类
类一旦继承了Thread类，这个类就是线程类
方法
| 方法名 | 说明 |
|---|---|
| void run() | 在线程开启后，此方法将被调用执行 |
| void start() | 使此线程开始执行，Java虚拟机会调用run方法() |
继承Thread类
步骤
定义类去继承Thread类并重写run()方法
创建这个类的对象
调用对象.start()方法，开启线程
public class MyThread extends Thread{
@Override
public void run() {
for(int i = 0;i < 100;i++){
System.out.println(i);
}
}
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
//开启线程
myThread.start();
}实现Runnable接口
Thread构造方法
| 方法名 | 说明 |
|---|---|
| Thread(Runnable target) | 分配一个新的Thread对象 |
| Thread(Runnable target, String name) | 分配一个新的Thread对象 |
步骤
创建类实现Runnable接口并重写run()方法
创建这个类对象
将这个对象传入Thread类的有参构造器中创建Thread对象
调用start()方法开启线程
public class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(i);
}
}
}
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
//开启线程
thread.start();
}实现Callable接口
方法
| 方法名 | 说明 |
|---|---|
| V call() | 计算结果，如果无法计算结果，则抛出一个异常 |
| FutureTask(Callable callable) | 创建一个 FutureTask，一旦运行就执行给定的 Callable |
| V get() | 如有必要，等待计算完成，然后获取其结果 |
步骤
定义一个类MyCallable实现Callable接口
在MyCallable类中重写call()方法
创建MyCallable类的对象
创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
创建Thread类的对象，把FutureTask对象作为构造方法的参数
启动线程
再调用get方法，就可以获取线程结束之后的结果
public class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println(i);
}
return "线程执行完毕!";
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask<String> task = new FutureTask<>(new MyCallable());
// System.out.println(task.get());//一定要开启线程后才能获取到线程返回值
Thread thread = new Thread(task);
//开启线程
thread.start();
System.out.println(task.get());
}三种实现方式的对比
实现Runnable、Callable接口
好处: 扩展性强，实现该接口的同时还可以继承其他的类
缺点: 编程相对复杂，不能直接使用Thread类中的方法
继承Thread类
好处: 编程比较简单，可以直接使用Thread类中的方法
缺点: 可以扩展性较差，不能再继承其他的类
三、线程相关方法
3.1 设置和获取线程名称
方法介绍
| 方法名 | 说明 |
|---|---|
| void setName(String name) | 将此线程的名称更改为等于参数name |
| String getName() | 返回此线程的名称 |
| Thread currentThread() | 返回对当前正在执行的线程对象的引用 |
public static void main(String[] args) {
MyThread t = new MyThread();
t.setName("灰二");
t.start();
System.out.println(t.getName());
System.out.println(Thread.currentThread().getName());
}注意
设置线程名需要在线程开启前设置
获取当前线程是指 : 获得所处位置的线程
3.2 线程休眠
方法介绍
| 方法名 | 说明 |
|---|---|
| static void sleep(long millis) | 使当前正在执行的线程停留（暂停执行）指定的毫秒数 |
public static void main(String[] args) {
try {
System.out.println("开始休眠！");
Thread.sleep(1000);//使主线程睡眠 1s
System.out.println("休眠结束！");
} catch (InterruptedException e) {
e.printStackTrace();
}
}3.3 线程优先级
线程调度
两种调度方式
分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些
Java使用的是抢占式调度模型
相关方法
| 方法名 | 说明 |
|---|---|
| final int getPriority() | 返回此线程的优先级 |
| final void setPriority(int newPriority) | 更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10 |
public static void main(String[] args) {
MyThread t0 = new MyThread();
t0.setPriority(1);
MyThread t1 = new MyThread();
t1.setPriority(10);
//设置 t1线程的优先级高于t0线程
t0.start();
t1.start();
System.out.println("t0优先级 : "+t0.getPriority());
System.out.println("t1优先级 : "+t1.getPriority());
}线程设置优先级并不能一定保证优先级高的一定先执行
3.4 守护线程
方法介绍
| 方法名 | 说明 |
|---|---|
| void setDaemon(boolean on) | 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出 |
public static void main(String[] args) {
DaemonThread daemon = new DaemonThread();
daemon.setDaemon(true);
daemon.start();
for(int i = 0;i < 5;i++){
System.out.println(Thread.currentThread().getName()+"输出 : "+i);
}
}注意
设置守护线程需要在线程开启前
当其它线程运行完毕后，守护线程也会停止运行，但是不会立即停止
四、线程同步
经典案例——卖票
错误实现
public class SellTicket implements Runnable{
private int tickets = 100;
@Override
public void run() {
while (true){
if(tickets > 0){
Thread t = Thread.currentThread();
System.out.println(t.getName()+"出售1张，当前剩余"+(--tickets)+"张！");
}else{
System.out.println("售票结束！");
break;
}
}
}
}
public static void main(String[] args) {
SellTicket ticket = new SellTicket();
Thread t1 = new Thread(ticket);
t1.setName("窗口1");
Thread t2 = new Thread(ticket);
t2.setName("窗口2");
Thread t3 = new Thread(ticket);
t3.setName("窗口3");
System.out.println("——————开始售票——————");
t1.start();
t2.start();
t3.start();
}
卖票案例的问题
卖票出现了问题
相同的票出现了多次
出现了负数的票
产生原因
线程执行的随机性（cpu随机挑选线程）导致的,可能在卖票过程中丢失cpu的执行权,导致出现问题
同步代码块解决问题
安全问题出现的条件
是多线程环境
有共享数据
有多条语句操作共享数据
如何解决多线程安全问题
让程序没有安全问题的条件
如何实现
把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
Java提供了同步代码块的方式来解决
同步的好处和弊端
好处：解决了多线程的数据安全问题
弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
同步代码块的现实例子 : 只有一个厕所，厕所如果已经有人进入会将门锁上，其他人不能进入，直到已经进入厕所的人开锁出来其他人才可以进入
-
同步代码快格式
-
synchronized(任意对象) { 多条语句操作共享数据的代码(只要出现了共享资源被操作，就需要出现在同步代码块中) }synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁
同一时刻只能有一个线程进入代码块
-
public class SellTicket implements Runnable{
private int tickets = 100;
@Override
public void run() {
while (true){
synchronized (this){
if(tickets > 0){
Thread t = Thread.currentThread();
System.out.println(t.getName()+"出售1张，当前剩余"+(--tickets)+"张！");
}else{
System.out.println("售票结束！");
break;
}
}
}
}
}
public static void main(String[] args) {
SellTicket ticket = new SellTicket();
Thread t1 = new Thread(ticket);
t1.setName("窗口1");
Thread t2 = new Thread(ticket);
t2.setName("窗口2");
Thread t3 = new Thread(ticket);
t3.setName("窗口3");
System.out.println("——————开始售票——————");
t1.start();
t2.start();
t3.start();
}同步方法解决问题
-
同步方法格式
修饰符 synchronized 返回值类型 方法名(方法参数) { 方法体； }同步方法的对象是this，也就是调用者，同一个调用者可以实现开锁和加锁
-
静态同步方法格式
修饰符 static synchronized 返回值类型 方法名(方法参数) { 方法体； }静态同步方法的对象是 类名.class
同步方法
public class SellTicket implements Runnable{
private int tickets = 100;
@Override
public void run() {
sell();
}
private synchronized void sell(){
while (true){
if(tickets > 0){
Thread t = Thread.currentThread();
System.out.println(t.getName()+"出售1张，当前剩余"+(--tickets)+"张！");
}else{
System.out.println("售票结束！");
break;
}
}
}
}
public static void main(String[] args) {
SellTicket ticket = new SellTicket();
Thread t1 = new Thread(ticket);
t1.setName("窗口1");
Thread t2 = new Thread(ticket);
t2.setName("窗口2");
Thread t3 = new Thread(ticket);
t3.setName("窗口3");
System.out.println("——————开始售票——————");
t1.start();
t2.start();
t3.start();
}静态同步方法
public class SellTicket implements Runnable{
private static int tickets = 100;
@Override
public void run() {
sell();
}
private static synchronized void sell(){
while (true){
if(tickets > 0){
Thread t = Thread.currentThread();
System.out.println(t.getName()+"出售1张，当前剩余"+(--tickets)+"张！");
}else{
System.out.println("售票结束！");
break;
}
}
}
}
public static void main(String[] args) {
SellTicket ticket = new SellTicket();
Thread t1 = new Thread(ticket);
t1.setName("窗口1");
Thread t2 = new Thread(ticket);
t2.setName("窗口2");
Thread t3 = new Thread(ticket);
t3.setName("窗口3");
System.out.println("——————开始售票——————");
t1.start();
t2.start();
t3.start();
}Lock锁
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
ReentrantLock构造方法
| 方法名 | 说明 |
|---|---|
| ReentrantLock() | 创建一个ReentrantLock的实例 |
加锁、解锁
| 方法名 | 说明 |
|---|---|
| void lock() | 获得锁 |
| void unlock() | 释放锁 |
public class SellTicket implements Runnable{
private int tickets = 100;
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true){
try{
lock.lock();
if(tickets > 0){
Thread t = Thread.currentThread();
System.out.println(t.getName()+"出售1张，当前剩余"+(--tickets)+"张！");
}else{
System.out.println("售票结束！");
break;
}
}finally {
lock.unlock();//需要关闭锁资源
}
}
}
}
public static void main(String[] args) {
SellTicket ticket = new SellTicket();
Thread t1 = new Thread(ticket);
t1.setName("窗口1");
Thread t2 = new Thread(ticket);
t2.setName("窗口2");
Thread t3 = new Thread(ticket);
t3.setName("窗口3");
System.out.println("——————开始售票——————");
t1.start();
t2.start();
t3.start();
}注意事项（使用try-finally，关闭 lock锁资源）
死锁
线程死锁是指 : 由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行
什么情况下会产生死锁
资源有限
同步嵌套
public static void main(String[] args) {
Object objA = new Object();
Object objB = new Object();
new Thread(() -> {
while (true) {
synchronized (objA) {
//线程一
synchronized (objB) {
System.out.println("小康同学正在走路");
}
}
}
}).start();
new Thread(() -> {
while (true) {
synchronized (objB) {
//线程二
synchronized (objA) {
System.out.println("小薇同学正在走路");
}
}
}
}).start();
}五、生产者和消费者
概述
生产者
消费者
共享的资源
Object类的等待和唤醒方法
| 方法名 | 说明 |
|---|---|
| void wait() | 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法 |
| void notify() | 唤醒正在等待对象监视器的单个线程 |
| void notifyAll() | 唤醒正在等待对象监视器的所有线程 |
public class Desk {
private boolean flag;
//public static int count = 10;
private int count;
//锁对象
//public static final Object lock = new Object();
private final Object lock = new Object();
public Desk() {
this(false, 10);
}
public Desk(boolean flag, int count) {
this.flag = flag;
this.count = count;
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public Object getLock() {
return lock;
}
}
public class Cooker extends Thread {
private Desk desk;
public Cooker(Desk desk) {
this.desk = desk;
}
@Override
public void run() {
while (true) {
synchronized (desk.getLock()) {
if (desk.getCount() == 0) {
break;
} else {
//System.out.println("验证一下是否执行了");
if (!desk.isFlag()) {
//生产
System.out.println("厨师正在生产汉堡包");
desk.setFlag(true);
desk.getLock().notifyAll();
} else {
try {
desk.getLock().wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
}
public class Foodie extends Thread {
private Desk desk;
public Foodie(Desk desk) {
this.desk = desk;
}
@Override
public void run() {
while (true) {
synchronized (desk.getLock()) {
if (desk.getCount() == 0) {
break;
} else {
if (desk.isFlag()) {
System.out.println("吃货在吃汉堡包");
desk.setFlag(false);
desk.getLock().notifyAll();
desk.setCount(desk.getCount() ‐ 1);
} else {
try {
desk.getLock().wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
}
public class Demo {
public static void main(String[] args) {
Desk desk = new Desk();
Foodie f = new Foodie(desk);
Cooker c = new Cooker(desk);
f.start();
c.start();
}
}阻塞队列
概述
常见BlockingQueue:
ArrayBlockingQueue: 底层是数组,有界
LinkedBlockingQueue: 底层是链表,无界.但不是真正的无界,最大为int的最大值BlockingQueue的核心方法:
put(anObject): 将参数放入队列,如果放不进去会阻塞
take(): 取出第一个数据,取不到会阻塞
public static void main(String[] args) throws InterruptedException {
//创建阻塞队列的对象，容量为1
ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(1);
//存储元素
arrayBlockingQueue.put("汉堡包");
//取元素
System.out.println(arrayBlockingQueue.take());
System.out.println(arrayBlockingQueue.take());//如果取不到，会阻塞，程序不会停止运行
System.out.println("程序结束了！");
}阻塞队列实现等待唤醒机制（生产 消费）
public class Cooker implements Runnable {
private ArrayBlockingQueue<String> bd;
public Cooker() {
}
public Cooker(ArrayBlockingQueue<String> arrayBlockingQueue) {
bd = arrayBlockingQueue;
}
@Override
public void run() {
while (true) {
try {
bd.put("汉堡包");
System.out.println("厨师放入一个汉堡包");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Foodie implements Runnable {
private ArrayBlockingQueue<String> bd;
public Foodie() {
}
public Foodie(ArrayBlockingQueue<String> arrayBlockingQueue) {
bd = arrayBlockingQueue;
}
@Override
public void run() {
while (true) {
try {
String take = bd.take();
System.out.println("吃货将" + take + "拿出来吃了");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
ArrayBlockingQueue<String> bd = new ArrayBlockingQueue<>(1);
Foodie f = new Foodie(bd);
Cooker c = new Cooker(bd);
new Thread(f).start();
new Thread(c).start();
}
扫一扫
1884
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
