多线程笔记

多线程笔记

Process（进程）与Thread(线程)

1. 程序是指令和数据的有序集合，其本身没有任何运行的含义，只是一个静态的概念
2. 而进程则是执行程序的一次执行过程， 它是一个动态的概念，是系统资源分配的单位
3. 一个进程包含多个线程，但是最少都要一个进程有一个线程，线程是CPU调度和执行的单位

真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即一个CPU的情况下，在同一个时间点，CPU只能

执行一个代码，因为切换的很快，所以就同时执行的

线程三中创建方式

1. 继承Thread 类

   继承Thread重写run()方法，调用start开启线程

   线程不一定立即执行，由CPU调度执行

   不建议使用：避免OOP单继承局限性

2. 实现Runnable接口

   重写run()方法，执行线程需要丢入runnable接口实现类，调用start方法

   推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

3. 实现Callable接口 需要返回值

   重写call方法，需要抛出异常

   创建目标对象

   创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1); 本人理解就是一个盒子里面有三个框

   提交执行：future result1 = ser.submit(t1);

   获取结果：boolean r1= result1.get();

   关闭服务：ser.shutdownNow();

   ---

   获取线程名字

   ​ Thread.currentThread().getName()

   模拟延时

   ​ Thread.sleep(时间)

   静态代理总结

   ​ new Thread(()->{}).start(); 其实就是静态代理 Runnable就是真实角色 用 Lamda表达式 ()->{}

   ​ 真实对象和代理对象都要实现同一个接口

   ​ 代理对象要代理真实角色

   代理对象可以做很多真实对象做不了的事情

   真实对象专注做自己的事情

Lamda表达式

理解Functional Interface(函数式接口) 是学习Java8 lambda表达式的关键所在

函数式接口的定义：

​ 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。

public interface Runnable{
    public abstract void run();
}

对于函数式接口，我们可以通过lambda表达式来创建该接口的对象

线程状态

sleep 现成休眠

1. sleep制定当前线程阻塞的毫秒数
2. sleep存在的异常InterruptedException
3. sleep时间达到后线程进入就绪状态
4. sleep可以模拟网络延时，倒计时
5. 每一个对象都有一个锁，sleep不会释放锁

线程礼让 yield

1. 礼让线程，让当前正在执行的线程暂停，但是不阻塞
2. 将线程从运行状态转为就绪状态
3. 让CPU重新调度，礼让不一定成功

join

1. join合并线程，待此线程执行完成后，在执行其他线程，其他线程阻塞
2. 相当于VIP大佬插队

守护线程（daemon）

线程分为用户线程和守护线程

虚拟机必须确保用户线程执行完毕

虚拟机不用等待守护线程执行完毕

如后台记录操作日志，监控内存，垃圾回收等待

线程同步

多个线程同时操作一个资源

并发问题，当多个用户操作同一个线程时，而且某些线程还需要修改这个对象，那么就需要线程同步，其实就是队列，一个个来保证不会导致出现问题

队列和锁

队列就是排队、

锁是保证线程安全

队列+锁才能保证同步的安全性

synchronized

由于同一进程的多个线程共享同一块储存空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制，synchronized,当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题：

1. 一个线程持有锁会导致其他所有需要此锁的线程挂起
2. 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
3. 如果一个优先级高的线程等带一个优先级低的线程释放锁会会导致优先级倒置，引起性能问题

方法里面需要修改的内容才需要加锁，锁的太多，容易浪费资源

synchronized 锁的是对象 this

同步块 synchronized (obj){} obj称之为同步监视器 锁的对象就是变化的量，是需要增删改的对象

死锁

多个线程各自有自己的资源，并且互相等待其他线程占有的资源才能运行

死锁就是两个线程互相等待对方释放资源，从而停止执行。

死锁避免方法

产生死锁的四个必要条件

1. ​ 互斥条件：一个资源每次只能被一个进程使用
2. ​ 请求与保持：一个进程因为请求资源而阻塞时，对方获得的资源保持不放
3. ​ 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
4. ​ 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

lock(锁)

ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock,可以显示加锁，释放锁

synchronized与lock的对比

Lock是显式锁（手动开启和关闭） synchronized是隐式锁，出了作用域就自动释放

lock只有代码块锁，synchronized有方法所和代码块锁

使用Lock锁,jvm将话费较少的时间来调度线程，性能更好，并且具有更好的扩展性

优先使用顺序

​ Lock>同步代码块>同步方法

线程协作

生产者消费者模式

​ 这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件

就是相当于生产者造出东西，消费者消费东西

当没有产品时，生产者告知消费者等待，生产完产品，叫消费者消费

当消费者消费后，通知生产者消费结束，需要生产新的产品以供消费

线程通信

解决方法

一个管城法 有一个缓冲区

一个信号灯法 有一个标志位

线程池

1. 背景：经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
2. 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中
3. 可以避免频繁创建销毁，实现重复利用，类似于小遛单车
4. 好处：

• ​ 提高响应速度（减少了创建新线程的时间）

• ​ 降低资源小号（重复利用线程池中线程，不需要每次创建）

• ​ 便于线程管理

  ​ corePoolSize:核心池的大小

  ​ maximunPookSize:最大线程数

  ​ keepAliveTime:线程没有任务时最多保持多长时间后会终止

ExecutorService 和Executors

ExecutorService:真正的线程池接口。常见的子类ThreadPoolExecutor

​ void execute(Runnable command):执行任务/命令。没有返回值，一般用来执行Runnable

​ Future submit(Callable task):执行任务 有返回值一般用来执行callable

Executors：工具类。线程池的工厂类。用于创建并返回不同类型的线程池