来，让我们聊聊Java的多线程
本博客可以回答以下问题：
- 什么是线程？区别于进程？
- 线程调度是什么？
- Java怎么创建线程？然后怎么县城如何运行？
- 线程池？Java怎么创建和调用线程池？
大话多线程
基础知识
程序运行的进程好比一家人干饭的过程，单线程是同时只有一个人吃饭，多线程是同时多个人一起吃饭饭
线程与进程
进程
是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间
线程
- 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程
- 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程
线程调度
-
分时调度
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间 -
抢占式调度
- 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
- CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。
同步与异步
- 同步:排队执行 , 效率低但是安全
- 异步:同时执行 , 效率高但是数据不安全
并发与并行
- 并发：指两个或多个事件在 同一个时间段内 发生
- 并行：指两个或多个事件在 同一时刻 发生（同时发生）
Java创建线程
Java创建的线程，调度为抢占式调度。博主使用JDK11
1 继承Thread类
示例代码：
public class MyThread extends Thread {
/**
* run()里写线程执行的代码, 调用start()启动线程
*/
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.printf("我是一只小绵羊，代号：%4d\n", i);
}
System.out.println("MyThread执行结束");
}
}
主程序：
public static void main(String[] args) {
MyThread m = new MyThread();
m.start();
for (int i = 0; i < 10; i++) {
System.out.printf("我是一只大灰狼，代号：%4d\n", i);
}
System.out.println("主程序执行结束");
}
2 实现Runnable接口
示例代码：
public class MyRunnable implements Runnable{
@Override
public void run() { //实现抽象方法
for (int i = 0; i < 10; i++) {
System.out.printf("我是一只小绵羊，代号：%4d\n", i);
}
System.out.println("MyRunnable执行结束");
}
}
主程序：
public static void main(String[] args) {
//1,创建任务
MyRunnable r = new MyRunnable();
//2,任务分配线程
Thread t = new Thread(r);
t.start();
for (int i = 0; i < 10; i++) {
System.out.printf("我是一只大灰狼，代号：%4d\n", i);
}
System.out.println("主程序执行结束");
}
3 实现Callable接口(了解，用不多)
线程执行完带有返回值。示例代码
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable<Integer> c = new MyCallable();
FutureTask<Integer> task = new FutureTask<>(c);
new Thread(task).start();
int i = 0;
i= task.get();//提前执行完
System.out.println(i);
for (int j = 0; j < 5; j++) {
Thread.sleep(100);
System.out.println("main:" + j);
}
}
static class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
for (int j = 0; j < 5; j++) {
Thread.sleep(100);
System.out.println("Callable:" + j);
}
return 100;
}
}
Thread和Runnable比较
实现Runnable与继承Thread相比有如下优势
- 通过创建任务，然后给线程分配任务的方式实现多线程，更适合多个线程同时执行任务的情况
- 可以避免单继承所带来的局限性
- 任务与线程是分离的，提高了程序的健壮性
- 后期学习的线程池技术，接受Runnable类型的任务，
不接受Thread类型的线程
Thread的常用静态方法
//获取线程的名称
System.out.println(Thread.currentThread().getName());
//线程的休眠 1000ms
Thread.sleep(1000);
//线程的休眠 1000ms + 50ns
Thread.sleep(1000, 50);
代码案例
public class Demo3 {
public static void main(String[] args) throws InterruptedException {
System.out.println(Thread.currentThread().getName());
Thread t = new Thread(new DemoRunnable(),"小绵羊");//线程起个名字：小绵羊
/*
* 线程分为守护线程和用户线程
* 用户线程：当一个进程不包含任何的存活的用户线程时，进行结束
* 守护线程:守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。
* 塔在人在，塔亡人亡
*/
t.setDaemon(true); //true : 表示设置成守护线程
t.start();
for (int i = 0; i < 5; i++) {
System.out.println("我是第 " + i + " 只快乐的大灰狼!");
Thread.sleep(1000);
}
/*
* interrupt() : 抛出中断,线程内部停止
*/
//t.interrupt();
}
static class DemoRunnable implements Runnable {
@Override
public void run() {
//获取线程的名称
System.out.println(Thread.currentThread().getName());
for (int i = 0; i < 10; i++) {
//线程的休眠
System.out.println("我是第 " + i + " 只快乐的小绵羊!");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
//e.printStackTrace();
//System.out.println("发现中断标记，但我就是不死亡!");
System.out.println("发现中断标记，绵羊线程择自杀!");
return;
}
}
}
}
}
线程安全
回到吃饭的场景，你要吃一块美味的红烧肉，夹起来到嘴边要吃的时候没了，你吃了一嘴空气。回头一看妹妹正在嚼着，此时你想打妹妹一顿……
线程不安全的解决方法：使用synchronized关键字为隐式锁；使用Lock类手动上锁解锁为显式锁，显示锁的公平锁是指按顺序先到先得先开锁，不公平锁是抢占式调度开锁，抢去吧👍
通俗的讲，就是让那块肉安全起来。我这就用售卖周董的演唱会门票为例：
public static void main(String[] args) {
//线程不安全
Runnable run = new Ticket();
new Thread(run).start();
new Thread(run).start();
new Thread(run).start();
}
static class Ticket implements Runnable {
//总票数
private int count = 10;
@Override
public void run() {
while (count > 0) {
//卖票
System.out.println("正在准备卖票");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println("卖票结束,余票：" + count);
}
}
}
}
结果就是：余票负数，而且没有次序
方案1 同步代码块
synchronized(){}看代码：
static class Ticket implements Runnable {
//总票数
private int count = 10;
private Object o = new Object();
@Override
public void run() {
//Object o = new Object(); //这里不是同一把锁，所以锁不住
while (true) {
synchronized (o) {
if (count > 0) {
//卖票
System.out.println("正在准备卖票");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println(Thread.currentThread().getName() + "卖票结束,余票：" + count);
} else {
break;
}
}
}
}
}
方案2 同步方法
使用synchronized修饰方法。看代码：
static class Ticket implements Runnable{
//总票数
private int count = 10;
@Override
public void run() {
while (true) {
boolean flag = sale();
if(!flag){
break;
}
}
}
public synchronized boolean sale(){
if (count > 0) {
//卖票
System.out.println("正在准备卖票");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
return true;
}
return false;
}
}
方案3 显示锁
创建锁，然后手动上锁、开锁。注意是多个线程开一把锁，如果是100个线程开100把锁，还是不安全。
static class Ticket implements Runnable{
//总票数
private int count = 10;
//参数为true表示公平锁 默认是false 不是公平锁
private Lock l = new ReentrantLock(true);
@Override
public void run() {
while (true) {
l.lock();
if (count > 0) {
//卖票
System.out.println("正在准备卖票");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
}else {
l.unlock();//别忘记解锁，不然程序无法结束
break;
}
l.unlock();
}
}
}
死锁
死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程1。——链接百度百科
写个死锁
罪犯和警察就这样僵持着，人质表示很慌= =
代码如下
线程的六个状态
我画了一张图，线程可以处于以下状态之一2：
NEW
尚未启动的线程处于此状态。
RUNNABLE
在Java虚拟机中执行的线程处于此状态。
BLOCKED
被阻塞等待监视器锁定的线程处于此状态。
WAITING
无限期等待另一个线程执行特定操作的线程处于此状态。
TIMED_WAITING
正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。
TERMINATED
已退出的线程处于此状态。
线程在给定时间点只能处于一种状态。 这些状态是虚拟机状态，不反映任何操作系统线程状态。
线程池
如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。
线程池的好处：
- 降低资源消耗。
- 提高响应速度。
- 提高线程的可管理性。
- 缓存线程池
/**
* 缓存线程池.
* (长度无限制)
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在,则创建线程 并放入线程池, 然后使用
*/
ExecutorService service = Executors.newCachedThreadPool();
// 分配线程执行，入参为实现Runnable接口的对象
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"小绵羊");
}
});
- 定长线程池
/**
* 定长线程池.
* (长度是指定的数值)
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*/
ExecutorService service = Executors.newFixedThreadPool(2);
- 单线程线程池
/**
* 单线程线程池.效果与定长线程池 创建时传入数值1 效果一致.
* 执行流程:
* 1. 判断线程池 的那个线程 是否空闲
* 2. 空闲则使用
* 4. 不空闲,则等待 池中的单个线程空闲后 使用
*/
ExecutorService service = Executors.newSingleThreadExecutor();
- 周期性任务定长线程池
/**
* 周期任务 定长线程池.
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*
* 周期性任务执行时:
* 定时执行, 当某个时机触发时, 自动执行某任务 .
*/
ScheduledExecutorService service = Executors.newScheduledThreadPool(2); // 指挥线程池运行线程
//定时执行一次
//参数1：定时执行的任务
//参数2：时长数字
//参数3：2的时间单位 TimeUnit的常量指定
service.schedule(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "小绵羊");
}
},5, TimeUnit.SECONDS);
/*
周期性执行任务
参数1：任务
参数2：延迟时长数字（第一次在执行上面时间以后
参数3：周期时长数字（没隔多久执行一次）
参数4：时长数字的单位
*/
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "小绵羊");
}
},5,10,TimeUnit.SECONDS);
Lambda表达式
个人理解 : 其实就是保留 入参->方法体 的结构
ExecutorService service = Executors.newFixedThreadPool(2);
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"小绵羊");
}
});
//void execute(Runnable command);
//要实现唯一抽象方法
service.execute(()-> System.out.println(Thread.currentThread().getName()+"大灰狼"));
说在结尾
到这儿已经结束了，听懂了吗？原理就那么多，使用的类几乎都是封装好的，手敲一遍就好了
Bye~
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
