多线程相关

1.线程与进程

  进程是指一个内存中运行的应用程序，每个进程都有一个独立空间。线程是进程的执行路径，共享一个内存空间。线程之间可互相切换，可并发执行，但是一个进程至少有一个线程。线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分 成若干个线程。

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

2.线程调度

2.1 分时调度：

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

2.2 抢占式调度：

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

3.同步与异步

同步:排队执行 , 效率低但是安全.

异步:同时执行 , 效率高但是数据不安全.

4.并发与并行

并发：指两个或多个事件在同一个时间段内发生。

并行：指两个或多个事件在同一时刻发生（同时发生）。

5.Java中的应用

1.继承Thread

public class MyThread extends Thread{
    /**
     * run方法就是线程要执行的任务方法
     */
    @Override
    public void run(){
        //这里的代码就是新执行路径
        //不是调用run()使用而是用start();
    }
}

2.实现接口runnable

public class MyRunnable implements Runnable {
public static void main(String[] args){
//1.创建一个任务对象
MyRunnable r = new MyRunnable();
//2.创建线程，并分配一个任务
Thread t = new Thread(r);

//执行
t.start()

}
    @Override
    public void run() {
        //线程任务
    }
}

3.Callable

interface Callable<V>

可以用在主线程中，让主线程等待其返回值再继续进行。

Callable使用步骤：

//1. 编写类实现Callable接口 , 实现call方法
class XXX implements Callable<T> {
  @Override
  public <T> call() throws Exception {
  return T;
}
}
//2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象
FutureTask<Integer> future = new FutureTask<>(callable);
//3. 通过Thread,启动线程
new Thread(future).start();

 使用get(long timeout, TimeUnit unit)方法来获取返回值，会使主线程等待其执行结果，可以设置等待时间，若超时则主线程继续运行。

比起继承Thread，实现runnable更适合多个线程同时执行同个任务。因为java中继承只能继承一个类，而实现可以多个，所以比起继承Thread，Runnable局限性更少。由于任务与线程本身分离，提高了程序的健壮性。线程池不接受Thread类型的线程。

Thread的Stop()方法已经停止使用，因为容易造成不必要的错误，一般通过变量标记的方法设置一个合理的return来使方法结束。

daemon线程（守护线程）和用户线程最大的区别在于其死亡时期，用户线程能自己决定死亡时机，而守护线程在所有用户线程死亡后自动死亡。

查看当前thread名称

Thread.currentThread().getName()

休眠是thread的静态方法，可以直接调用。当需要程序间隔一段时间的时候使用。括号里面填入long 类型的数字表示的毫秒值或者毫秒加纳秒组成的时间。

Thread.sleep()

线程状态。 线程可以处于以下状态之一：

• NEW 
  尚未启动的线程处于此状态。
• RUNNABLE 
  在Java虚拟机中执行的线程处于此状态。
• BLOCKED 
  被阻塞等待监视器锁定的线程处于此状态。
• WAITING 
  无限期等待另一个线程执行特定操作的线程处于此状态。
• TIMED_WAITING 
  正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。
• TERMINATED 
  已退出的线程处于此状态。

3.线程阻塞（耗时操作）

所有比较消耗时间的操作比如文件读取，接收用户输入都可以当成阻塞 。

4.中断线程

中断线程使用interrupt（）。监测到interrupt之后,当线程处于sleep或者Waite的时候就会进入InterruptedException,这时候就可以用return中断程序了。

5.线程安全

当多个线程进行同一个任务时在执行过程中若数据被改变会导致出现问题。通过添加锁来解决。

隐式锁简单易用且不会导致内存泄漏；而显式锁的过程完全要程序员控制，容易导致锁泄露； 隐式锁只是非公平锁；显示锁支持公平/非公平锁； 隐式锁无法限制等待时间、无法对锁的信息进行监控；显示锁提供了足够多的方法来完成灵活的功能； 一般来说，我们默认情况下使用隐式锁，只在需要显示锁的特性的时候才选用显式锁

解决方法: 隐式锁

1:同步代码块

格式：

synchronized(锁对象){
}

对象必须相同才能满足锁。

2.同步方法

格式：

public synchronized boolean sale(){
}

解决方法：显式锁(更能体现面向对象方法)

1. Lock 子类 ReentrantLock。当fair参数为true就表示为公平锁。

Lock l = new ReentrantLock();
l.lock();

执行完之后

l.unlock();

注意不要在有一个锁的线程中再加入第二个锁，不然可能会造成死锁。

6.线程池

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

线程池的好处：

降低资源消耗。

提高响应速度。

提高线程的可管理性

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. 定长线程池

/**
* 定长线程池.
* (长度是指定的数值)
* 执行流程:
3. 单线程线程池
4. 周期性任务定长线程池
* 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());
}
});

3. 单线程线程池

效果与定长线程池 创建时传入数值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());
 }
});

4. 周期性任务定长线程池

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);
}

7.Lambda表达式 

​​​​​​​删除类的部分保留方法参数和方法体，剩下的就是lambda表达式。

//可以省去冗余runnable代码
Thread t = new Thread(() ->{
  System.out.println("lambda")});
t.start();