文章目录
前言
博客仅记录个人学习进度和一些查缺补漏。
学习内容：BV17F411T7Ao
多线程
首先需要知道什么是进程什么是线程，详见408《操作系统》
进程是程序执行的实体，是资源调度的基本单位，处理机分配给每一个程序的资源都以进程为整体。
线程是进程中的实际运行单位，也是资源调度的最小单位。
以前的代码都是单线程程序
为了提高CPU的运行效率，应该使用多线程程序
并发与并行
详见408，重点内容
并发 ：指多个指令在单个CPU上交替执行
即在一定的时间周期内，多次进行作业调度，执行不同的指令
并行 ：指多个指令在多个CPU上同时执行
即在同一时刻上，多个CPU同时执行不同的指令
并发和并行在当前的处理机环境下会同时发生
多线程的实现方式
Thread类
表示java中的一个线程，任何继承该类的子类都可以重写其run方法，提示为多线程程序。
例如：在run中书写要执行的代码，使用start来启动线程
例如：多线程同时启动，指同一个程序（打印helloworld的代码体只有一个）的两个不同线程（t1和t2）同时工作，其中getname是Thread类的内置方法
Runnable接口
实现Runnable接口再重写run方法，本质上是一种描述任务的方法，实际多线程还是通过Thread对象来执行。
例如：先定义一个类，再实现接口，再run中描述具体的任务，Runnable默认是多线程模式，可以直接获取当前线程的对象。
例如：创建Myrun对象，将任务发布，可以通过多个线程对象来同时进行任务并分开结算
Callable接口和Future接口
Callable接口提示该类为描述多线程任务类，再call中描述具体的任务，并且给出返回值，将任务发布给Thread类的对象来完成，并通过Future类的对象来取得call的结果。
例如：任务发布类
例如：找一个工会柜员来管理这个任务的结果，需要注意的是一个柜员可以对应多个完成者的结算，每次接收的都是最后一个完成者（线程）完成的结果
例如：找一个冒险者（线程）来完成这个任务，并通过柜员（Future）来管理结果
Thread类的相关方法
线程对象
例如：查看线程的默认名字
发布任务
对于继承了Thread的类来说，相当于任务实体本身就是可以完成任务的单位（只做固定任务的打工人），属于远征类任务，点一下自己就完成了，不需要额外分配thread类（冒险者）来完成。
此时线程是有自己的默认名字的
例如：如果要进行名字的设置，可以通过构造方法（需要自己重写）也可通过setname成员方法
如果没有手动执行线程，默认线程也是有名字的，即虚拟机默认的main线程
例如：sleep可以手动阻塞线程使其停留一段时间（改时间内会让出CPU，并设置一个计时器，时间到则会从挂起态恢复成就绪态。
线程优先级
抢占式调度：多线程抢夺执行权，执行顺序和执行时间都是不确定的（实际上就是优先级来看的，优先级越高能抢到的总时间占比就越大，当作业到来的时候能优先享用CPU）
非抢占式调度：新作业到达时只能排队，不能抢，大伙轮流依次使用CPU
JAVA中使用了抢占式调度，分为10个优先级
例如：查看默认优先级，包括main线程，java中默认线程优先级都是5
例如：设置优先级
优先级越大，抢占的CPU资源就多，就能更早的执行结束
守护线程
仅仅是为了执行同一个任务的主线程而存在的分线程，来源于同一个任务模块，当被设置成守护线程以后，会为真勇者铺路，真勇者任务结束了，即使自己的任务没有完成，也应该结束。
例如：会陆续结束而不是立即结束
例如此时，传输文件就是聊天的守护线程（分线程）
出让线程/礼让线程
由任务版本身提出限制，执行完一次任务后应当让出CPU，让各个执行任务的实体对象相互分配使用CPU
例如：
插入线程/插队线程
在申明了该方法后，将申明的线程调度到当前进程的前面，可以优先使用CPU
例如在原过程中，自定义线程和main线程并发执行，相互抢夺CPU使用权：
例如：申明了插队以后（在某一个线程内进行插队），可以比当前的进程更快执行
线程的相关问题
生命周期
详见408
在更新了阻塞锁的概念以后，添加了新的生命周期：
安全问题
多线程常常会出现临界资源共享顺序问题，如果进入临界区不上锁，会导致临界资源的出错
例如：将电影票设置为static，成为多线程共享的临界资源
但是因为临界区没有上锁，各线程之间随意进出临界区，导致临界资源一下被这个线程改，一下被那个线程改。
比如此时，还没来得及打印，刚使ticket自增，就被抢夺了执行权
这就引出了临界区和锁的概念，如果能在指定区域上锁，就不会出现类似的问题，但是如果锁的区域太多，就变成了顺序执行的单线程，如果锁的区域太小，无法彻底解决临界资源异常。
例如：锁对象可以是任意的类型的任意对象，但一定要是唯一的，所以使用static
注意，同步代码块的位置很关键，如下会导致先进入同步块的线程一个人就把任务做完了
注意，同一个区块需要使用同一个锁对象，一般使用当前类的字节码文件对象
如果要将一个方法里的所有代码都锁起来，可以直接在方法上加入Synchronized关键字
例如：使用Runnable来发布任务，提供ticket参数供线程对象来使用，构建同步代码块
例如：将买票这一行为抽象成一个方法，提取出来，加上同步修饰
此时锁对象就是Runnable对象的字节码文件，是唯一的。
例如：String Builder是多线程不安全的，多线程的时候应该使用String Buffer类，显然String Buffer类的方法中都是添加了同步锁的
Lock锁
例如：
就是在同步代码块进入区域上锁，出去的区域开锁，但要注意创建出来的锁要具有唯一性，以及一定要有开锁的余地（可以使用finally来执行开锁）
死锁
当不同的锁之间出现了嵌套，两边都在等着对方释放临界资源，就会产生死锁
例如：根据同步代码块的锁对象的不同，产生两把锁
等待唤醒机制（生产者和消费者）
经典PV操作，408必考知识点。
例如：先创建桌子并添加锁变量
例如：在消费者的任务描述页面，要提示具体是哪一把锁前面有人排队，唤醒哪个锁队列中的人
例如：在生产者任务页面，要使用相同的锁对象来进行判断
通过阻塞队列实现
进入临界区时，会判断是否有数据，然后是否挂载到队列中，出临界区时看队列中有没有人，有人就提出来
例如：阻塞队列显然只能有一个，厨师的任务发布页如下，其中构造方法要求一定要传入阻塞队列
注意其中并没有锁，锁写到了队列的put方法中
例如：put源码
例如：客人的构造方法要求一定要传入阻塞队列，并且和对应的厨师保持一致，这样就能从公共队列中获取信息，其中take方法本身带锁
例如：take源码
例如：程序界面先创建共同阻塞队列对象，通过这个队列来创建厨师，需要注意的是，打印语句定义到了锁的外面，并不是临界区，所以会导致数据错误。
综合练习
package com.itheima.demo6;
public class CinemaThread extends Thread{
public static int ticket = 1000;
public CinemaThread(String s) {
this.setName(s);
}
@Override
public void run() {
while (true) {
synchronized (CinemaThread.class) {
if (ticket > 0) {
try {
sleep(3000);
ticket--;
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}else {
break;
}
System.out.println(this.getName() + "卖出了一张票，还剩" + ticket + "张票");
}
}
}
}
package com.itheima.demo6;
public class ThreadTest {
public static void main(String[] args) {
CinemaThread cinemaThread1 = new CinemaThread("窗口1");
CinemaThread cinemaThread2 = new CinemaThread("窗口2");
cinemaThread1.start();
cinemaThread2.start();
}
}
package com.itheima.demo6;
public class GiftSent extends Thread{
public static int giftNum = 100;
public GiftSent(String name) {
this.setName(name);
}
@Override
public void run() {
while (true) {
synchronized (GiftSent.class) {
if (giftNum > 10) {
giftNum--;
}else {
break;
}
System.out.println(this.getName() + "发出了一份礼物，还剩" + giftNum + "个");
}
}
}
}
package com.itheima.demo6;
public class ThreadTest {
public static void main(String[] args) {
GiftSent giftSent1 = new GiftSent("A学生");
GiftSent giftSent2 = new GiftSent("B学生");
giftSent1.start();
giftSent2.start();
}
}
package com.itheima.demo6;
public class OddCount extends Thread{
public static int count = 100;
public OddCount (String name) {
this.setName(name);
}
@Override
public void run() {
while (true){
synchronized (OddCount.class) {
if(count % 2 != 0) {
System.out.println(this.getName() + "找到了一个奇数:" + count);
}
if (count < 1) {
break;
}else {
count--;
}
}
}
}
}
package com.itheima.demo6;
public class ThreadTest {
public static void main(String[] args) {
OddCount oddCount1 = new OddCount("A");
OddCount oddCount2 = new OddCount("B");
oddCount1.start();
oddCount2.start();
}
}
package com.itheima.demo6;
import java.util.Random;
public class RedBag extends Thread{
public static int num = 3;
public static int red = 100;
public RedBag(String name) {
this.setName(name);
}
@Override
public void run(){
synchronized (RedBag.class) {
if (num > 1) {
int t = red;
num--;
red -= new Random().nextInt(red);
System.out.println(this.getName() + "抢到了" + (t - red) + "元");
}else if (num == 1) {
num--;
System.out.println(this.getName() + "抢到了" + red + "元");
}else {
System.out.println(this.getName() + "没抢到");
}
}
}
}
package com.itheima.demo6;
public class ThreadTest {
public static void main(String[] args) {
RedBag redBag1 = new RedBag("A");
RedBag redBag2 = new RedBag("B");
RedBag redBag3 = new RedBag("C");
RedBag redBag4 = new RedBag("D");
RedBag redBag5 = new RedBag("E");
redBag1.start();
redBag2.start();
redBag3.start();
redBag4.start();
redBag5.start();
}
}
package com.itheima.demo6;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
public class Bonus extends Thread{
public static ArrayList<Integer> integerArrayList = new ArrayList<>();
static {
Collections.addAll(integerArrayList, 10, 5, 20, 50, 100, 200, 500, 800, 2, 80, 300, 700);
}
public Bonus(String name) {
this.setName(name);
}
@Override
public void run() {
while (true) {
synchronized (Bonus.class) {
if(integerArrayList.isEmpty()) {
break;
}else {
int t = new Random().nextInt(integerArrayList.size());
System.out.println(this.getName() + "抽到了" + integerArrayList.get(t) + "元");
integerArrayList.remove(t);
}
}
}
}
}
package com.itheima.demo6;
public class ThreadTest {
public static void main(String[] args) {
Bonus bonus1 = new Bonus("抽奖箱1");
Bonus bonus2 = new Bonus("抽奖箱2");
bonus1.start();
bonus2.start();
}
}
package com.itheima.demo6;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
public class Bonus extends Thread{
public static ArrayList<Integer> integerArrayList = new ArrayList<>();
private ArrayList<Integer> integerArrayList1 = new ArrayList<>();
static {
Collections.addAll(integerArrayList, 10, 5, 20, 50, 100, 200, 500, 800, 2, 80, 300, 700);
}
public Bonus(String name) {
this.setName(name);
}
@Override
public void run() {
while (true) {
synchronized (Bonus.class) {
if(integerArrayList.isEmpty()) {
System.out.print(this.getName() + "抽到了" + integerArrayList1.size() + "个奖,分别为：");
String str = "";
int num = 0;
int max = 0;
for (Integer i : integerArrayList1) {
str += i + ",";
num += i;
max = max<=i?i:max;
}
str = str.subSequence(0, str.length() - 1).toString();
System.out.println(str + " 最高" + max +"元" + "，共计" + num + "元");
break;
}else {
int t = new Random().nextInt(integerArrayList.size());
this.integerArrayList1.add(integerArrayList.get(t));
integerArrayList.remove(t);
}
}
}
}
}
package com.itheima.demo6;
public class ThreadTest {
public static void main(String[] args) {
Bonus bonus1 = new Bonus("抽奖箱1");
Bonus bonus2 = new Bonus("抽奖箱2");
bonus1.start();
bonus2.start();
}
}
package com.itheima.demo6;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
public class Bonus extends Thread{
public static ArrayList<Integer> integerArrayList = new ArrayList<>();
private ArrayList<Integer> integerArrayList1 = new ArrayList<>();
private static int join_num = 2;
private static boolean flag = true;
private static int maxBonus = 0;
private static String name1 = "";
static {
Collections.addAll(integerArrayList, 10, 5, 20, 50, 100, 200, 500, 800, 2, 80, 300, 700);
}
public Bonus(String name) {
this.setName(name);
}
@Override
public void run() {
while (true) {
synchronized (Bonus.class) {
if(integerArrayList.isEmpty()) {
System.out.print(this.getName() + "抽到了" + integerArrayList1.size() + "个奖,分别为：");
String str = "";
int num = 0;
int max = 0;
for (Integer i : integerArrayList1) {
str += i + ",";
num += i;
max = max<=i?i:max;
}
str = str.subSequence(0, str.length() - 1).toString();
System.out.println(str + " 最高" + max +"元" + "，共计" + num + "元");
if(maxBonus <= max) {
maxBonus = max;
name1 = this.getName();
}
break;
}else {
int t = new Random().nextInt(integerArrayList.size());
this.integerArrayList1.add(integerArrayList.get(t));
integerArrayList.remove(t);
}
}
}
join_num--;
while (join_num > 0){
try {
sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException(e)
}
}
synchronized (Bonus.class) {
if (flag) {
System.out.println("最高奖" + maxBonus + "元，由" + name1 + "取得");
flag = !flag;
}
}
}
}
package com.itheima.demo6;
public class ThreadTest {
public static void main(String[] args) throws InterruptedException {
Bonus bonus1 = new Bonus("抽奖箱1");
Bonus bonus2 = new Bonus("抽奖箱2");
bonus1.start();
bonus2.start();
}
}
使用第三种有返回值的方法
package com.itheima.demo6;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
import java.util.concurrent.Callable;
public class Bonus implements Callable {
public static ArrayList<Integer> integerArrayList = new ArrayList<>();
private int max = 0;
static {
Collections.addAll(integerArrayList, 10, 5, 20, 50, 100, 200, 500, 800, 2, 80, 300, 700);
}
@Override
public Integer call() throws Exception {
ArrayList<Integer> integerArrayList1 = new ArrayList<>();
String name = Thread.currentThread().getName();
while (true) {
synchronized (Bonus.class) {
if(integerArrayList.isEmpty()) {
System.out.print(name + "抽到了" + integerArrayList1.size() + "个奖,分别为：");
String str = "";
int num = 0;
for (Integer i : integerArrayList1) {
str += i + ",";
num += i;
max = max<=i?i:max;
}
str = str.subSequence(0, str.length() - 1).toString();
System.out.println(str + " 最高" + max +"元" + "，共计" + num + "元");
break;
}else {
int t = new Random().nextInt(integerArrayList.size());
integerArrayList1.add(integerArrayList.get(t));
integerArrayList.remove(t);
}
}
}
return max;
}
}
package com.itheima.demo6;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class ThreadTest {
public static void main(String[] args) throws InterruptedException, ExecutionException {
Bonus bonus = new Bonus();
FutureTask<Integer> futureTask1 = new FutureTask<>(bonus);
FutureTask<Integer> futureTask2 = new FutureTask<>(bonus);
Thread bonus1 = new Thread(futureTask1);
Thread bonus2 = new Thread(futureTask2);
bonus1.setName("抽奖箱1");
bonus2.setName("抽奖箱2");
bonus1.start();
bonus2.start();
Integer num1 = futureTask1.get();
Integer num2 = futureTask2.get();
if(num1 > num2) {
System.out.println("抽奖箱1抽到了最大奖" + num1 + "元");
}else {
System.out.println("抽奖箱2抽到了最大奖" + num2 + "元");
}
}
}
线程池
以前通过多线程完成任务的时候，使用完线程就消亡了，每次创建进程都要重新分配资源，浪费很多时间
设置一个线程池，保存可以用来进行任务的线程（工人）
线程池可以理解成特殊的线程集合，任务可以直接发布给这个线程集合。（相当于一个工会）
每次给线程池提交一个任务都会发起一个新的线程来做事。
例如：无上限线程池
例如：有上限线程池，指只有三个线程做事
但是这个工具类不够灵活，每次都要手动排队
当阻塞队伍排满了，核心线程都在忙，才会创建临时线程
如果任务总数超过了核心数、临时数、队伍长度之和，就会触发任务拒绝策略
例如：创建参数详细的线程池
一般使用工具来测试
扫一扫
870
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
