多线程

# 多线程

# 并行和并发

并行：在同一时刻，有多个指令在多个 cpu 上同时执行

并发：在同一时刻，有多个指令在单个 CPU 上交替执行

# 进程和线程

# 进程

进程：是正在运行的软件

独立性：进程是一贯能独立运行的基本单位

动态性：进程的实质是程序的一次执行过程

并发性：任何进程都可以同其他进程一起并发执行

# 线程

线程：是进程中的单个顺序控制流，是一条执行路径

单线程：一个进程只有一条执行路径
多线程：一个进程拥有多个执行路径

# 继承 Thread

类继承 Thread 类
重写 run () 方法

public static class xian extends Thread {
    @Override
    public void run() {
        super.run();
    }
}

1
2
3
4
5
6

创建类对象
调用用 start () 方法启动线程交由 JVM 调用此线程的 run () 方法

public static void main(String[] args) {
    xian x = new xian();
    x.start();
}

1
2
3
4

# Runnable 接口

类实现 Runnable 接口
重写 run 方法

public static class xian2 implements Runnable{
    @Override
    public void run() {
        System.out.println("线程启动");
    }
}

1
2
3
4
5
6

创建类对象
```
xian2 x =new xian2();
```
1
创建 Thread 类对象，把类对象作为构造方法的参数
```
Thread t1 =new Thread(x);
```
1
启动线程
```
t1.start();
```
1

# Callable 接口与 Future

类实现 Callable 接口
重写 call () 方法

// 接口的泛型是call方法返回的类型
    public static class xian3 implements Callable<String> {
        @Override
        public String call() throws Exception {
            //返回的为线程执行完毕的结果,执行语句在方法体写
            return "你好多线程";
        }
    }

1
2
3
4
5
6
7
8

创建类对象
```
xian3 x = new xian3();
```
1
创建 Future 的实现类 FutureTask 对象，并将类对象作为构造方法参数传递

FutureTask<String> ft = new FutureTask<>(x);

创建 Thread 类对象，并把 FutureTask 对象作为构造方法参数传递
```
Thread t1 = new Thread(ft);
```
1
启动线程
```
t1.start();
```
1

// 获取线程执行完毕的结果,get方法一定在线程启动之后,否则get下面语句不执行
String s = ft.get();
System.out.println(s);

1
2
3

# Thread

# getName

获取线程名称，线程有默认名称为 Thread - 线程数

# setName

也可以通过构造方法设置线程名称

Thead 类中带有带参构造方法，可以给线程设置名称，但是继承的类必须使用 super 关键字引用.

# currentThread

返回当前正在执行的线程对象

String name = Thread.currentThread().getName();

如果 Runnable 接口或 Callble 接口想要使用 Thread 的方法可以

先捕抓到当前执行的线程再使用 Thread 的方法

# 线程休眠

sleep () 方法让线程休眠指定毫秒

Thread.sleep(1000);

# 线程调度

分时调度模型：所有线程轮流使用 cou 的使用权，平均分配每个线程占用 cpu 的时间片
抢占式调度模型：优先让优先级高的线程使用 cpu, 如果优先级相同，那么会随机选择一个，优先级高的线程获取 cpu 时间片相对多一些

# 线程的优先级

# getProiority

获取指定线程的优先级

Thread.currentThread().getPriority()

# setPriority

设置指定线程的优先级

默认为 5 范围 1-10

Thread.currentThread().setPriority(6);

优先级高不代表运行的时间相对减少

# 后台线程 / 守护线程

# setDaemon

需要传递一个布尔值，true 为设置为守护线程

当普通线程执行完后，那么守护线程没有继续执行下去的必要 (自动结束)

# 线程的安全问题

# 同步代码块

锁多条语句操作共享数据，可以使用同步代码块实现

Object obj =new Object();
// 传递任意对象,注意要是唯一的,否则线程认为是不同的同步锁
synchronized (obj){
    // 线程共享的操作数据
}

1
2
3
4
5

默认情况是打开的，只要有一个线程进去执行代码了，锁就会关闭，只有等代码块执行完毕才重新打开

同步的好处:

解决了多线程的数据安全问题

弊端:

当线程过多时，因为每个线程都会判断同步上的锁，耗费系统资源，运行效率降低

# 同步方法

在方法返回值前面加上关键字 synchronized, 该方法的所有代码都加上锁

此同步方法锁对象为 this

如果此同步方法是静态的则锁对象为类名.class

# Lock 锁

Lock 是接口不能直接实例化，我们通过它的实现类 ReentrantLock 来实例化

private ReentrantLock lock =new ReentrantLock();

# lock

lock.lock();

加锁

# unlock

lock.unlock();

释放锁

# 死锁

线程死锁是指由于两个或者多个线程互相持有对象所需要的资源，导致这些线程处于等待状态，无法前往执行

# 生成者消费者 (等待唤醒机制)

# 等待 wait

同步代码块中锁的对象是什么则 wait 方法在该对象调用

# 唤醒 notify

会随机唤醒该进程里的任意线程

# 唤醒所有 notifyall

锁的步骤:

while (true) 死循环
synchronized 同步锁，锁对象要唯一
判断，共享数据是否结束结束的操作
判断，共享数据是否结束没有结束的操作

# 阻塞队列实现等待唤醒机制

# ArrayBlockingQueue

底层是数组，有界，创建时通过带参构造方法，定义该阻塞队列的边界

# put

put ("元素"), 存储，底层有 lock 锁

# take

take () 取出，如果取不出则会一直等待，直到下一关元素 put 进阻塞队列

# LinkedBlockingQueue

底层是链表，无界。但不是真正的无界，默认最大为 int 的最大值，也可以通过带参构造方法，定义阻塞队列的边界

编辑

上次更新: 2023/12/06, 01:31:48

← File 多线程高级→

多线程