多线程的一点笔记

多线程

线程与进程
进程：是指一个内存中运行的应用程序，每一个进程都有独立的内存空间。
线程：是进程的中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程
至少有一个线程。一个进程启动后，里面的若干执行路径又可以划分为若干个线程。

线程调度：

分时调度：
所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。

抢占式调度：
优先让优先级高的线程使用CPU。如果线程的优先级相同，那么会随机选择一个（线程随机性），java使用的是抢占式调度。
CPU使用抢占式调度在多个线程间进行着高速的切换，对于CPU的一个核心而言，某个时刻，只能执行一个线程，而CPU在多个线程之间切换的速度相对于我们的感觉要快，看上去就是在同一时刻运行，其实，多线程程序并不能提高程序的运行速度，但能够提高运行效率，让CPU的使用率更高。

同步与异步
同步：排队执行，效率低但是安全。
异步：同时执行，效率高但是数据不安全。

并发与并行
并发：指的是两个或多个事件在同一个时间段内发生。
并行：指的是两个或多个事件在同一个时刻发生（同时发生）。

每个线程都拥有自己的栈空间，共用一份堆内存。

多线程技术：
实现Runnable 与继承Thread 相比有如下优势：
1、通过创建任务，然后给线程分配的方式来实现的多线程，更适合多个线程执行相同任务的情况，
2、可以避免单继承所带来的局限性
3、任务与线程本身是分离的，提高程序的健壮性
4、后续学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程。设置和获取线程名称：

setName(); 设置线程名称

Thread.currentThread().getName()  获取当前对象线程名称

线程的休眠

​ Thread. sleep()

线程的阻塞：
(所有比较消耗时间的操作) 又称耗时操作

线程的中断 添加中断标记 interrupt（）

一个线程是一个独立的执行路径，他是否应该结束，应该由其自身决定。

守护线程：setDaemon(true);

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

用户线程：当一个进程不包含任何的存活的用户线程时，进程结束。

守护线程：守护用户线程的，当最后一个线程结束时，所有守护线程自动死亡。

线程不安全的原因：是因为多个线程同时执行去争抢一个数据，去同时操作一个数据，导致数据不一致，产生不符合预期的结果。

解决线程不安全的方法：

解决方案1：同步代码块

解决方案2：同步方法

解决方案3：显示锁 Lock 子类 ReentrantLock

公平锁：先来先到，排队

非公平锁：上面的三种处理方式都是不公平的锁

如何实现公平锁?

//显示锁 l :fair参数为true，就是表示公平锁
private Lock l = new ReentrantLock(true);

线程死锁：线程在锁定对象还没释放时，又需要锁定另一个对象，并且此时该对象可能被另一个线程锁定。这种时候很容易导致死锁。

线程的六种状态：

new ：尚未启动的线程处于此状态

Runnable: 在Java虚拟机中执行的线程处于此状态

Blocked ：被阻塞等待被监视锁定的线程处于此状态

Waiting : 无限期等待另一个线程执行特定操作的线程处于此状态

Timed Waiting ：正在等待另一个线程最多执行等待时间的操作的线程处于此状态

Terminated ：已退出的线程处于此状态。

带回返回值的线程Callable

Runnable 与 Callable

接口定义 
//Callable接口
public interface Callable {
       V call() throws Exception; 
} 
//Runnable接口
public interface Runnable {
       public abstract void run();
}

Callable使用步骤

1.编写类实现Callable接口 , 实现call方法
class XXX implements Callable { 

@Override

 public  call() throws Exception {
 return T;
 }
} 
2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象 
      FutureTask future = new FutureTask<>(callable); 
3. 通过Thread,启动线程 new Thread(future).start();

Runnable 与 Callable的相同点

都是接口

都可以编写多线程程序

都采用Thread.start()启动线程

Runnable 与 Callable的不同点

Runnable没有返回值；Callable可以返回执行结果

Callable接口的call()允许抛出异常；Runnable的run()不能抛出

Callable获取返回值

Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执 行，如果不调用不会阻塞。

线程池 Executors

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程 就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容 器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

创建线程

创建任务

执行任务

关闭线程

线程池的好处

降低资源消耗。

提高响应速度。

提高线程的可管理性。

Java中的四种线程池 . ExecutorService

1. 缓存线程池

​ (长度无限制)

​ 执行流程:

1. 判断线程池是否存在空闲线程
2. 存在则使用
3. 不存在,则创建线程 并放入线程池, 然后使用

ExecutorService service = Executors.newCachedThreadPool();
//向线程池中 加入 新的任务
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});

2.定长线程池

(长度是指定的数值)

执行流程:

1. 判断线程池是否存在空闲线程
2. 存在则使用
3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程

ExecutorService service = Executors.newFixedThreadPool(2);
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});

单线程线程池

效果与定长线程池 创建时传入数值1 效果一致.
/**
* 单线程线程池.
* 执行流程:
* 1. 判断线程池 的那个线程 是否空闲
* 2. 空闲则使用
* 4. 不空闲,则等待 池中的单个线程空闲后 使用
*/
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});

周期性任务定长线程池

public static void main(String[] args) {
/**
* 周期任务 定长线程池.
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*
* 周期性任务执行时:
* 定时执行, 当某个时机触发时, 自动执行某任务 .
*/
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
/**
* 定时执行
* 参数1. runnable类型的任务
* 参数2. 时长数字
* 参数3. 时长数字的单位
*/
/*service.schedule(new Runnable() {
@Override
public void run() {
System.out.println("俩人相视一笑~ 嘿嘿嘿");
}
},5,TimeUnit.SECONDS);
*/
/**
* 周期执行
* 参数1. runnable类型的任务
* 参数2. 时长数字(延迟执行的时长)
* 参数3. 周期时长(每次执行的间隔时间)
* 参数4. 时长数字的单位
*/
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("俩人相视一笑~ 嘿嘿嘿");
}
},5,2,TimeUnit.SECONDS);
}

Lambda 表达式

（参数类型 参数名）->{  代码语句 }