正在恶补的Java基础（三）

多线程

相关概念
程序和进程
程序：一个固定的存储有逻辑和数据的集合，是一个静态的状态，存储在磁盘上。
线程：一个正在运行着的程序，是一个动态的概念，一般运行在计算机的内存中。
进程和线程
进程：是一个正在运行的程序，会分配一部分系统资源，是一个独立的资源分配单位。
线程：一条正在独立执行的路径。
关系：进程使用于分配系统资源的单位；一个进程中可以有多条线程，一个进程中至少有一条线程；线程不会独立分配资源，一个进程内的所有线程，共享的是一个进程内的资源。
并发和并行
并行：在一个时间点有多个任务（进程、线程）正在执行，多核心、多CPU编程。
并发：在一个时间点，有多个任务同时发起。但是，在一个时间点，同时只能有一个任务正在运行。单核心、单CPU编程。

线程的创建和启动
实现方式

1. 继承Thread，重写run()方法

class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("我是谁我在哪，哦，感情在线程里");
    }
}
public class Test {
    public static void main(String[] args) {
        new MyThread().start();
    }
}

2. 实现Runable,实现run()方法

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println("我是谁我在哪，哦，感情在线程里");
    }
}
public class Test {
    public static void main(String[] args) {
        new Thread(new MyThread()).start();
    }
}

3. 实现Callable ，实现call()方法

class MulTest implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        return 1000;
    }
}
public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService ser = Executors.newFixedThreadPool(1);
        MulTest mulTest = new MulTest();
        Future<Integer> result = ser.submit(mulTest);
        int num = result.get();
        System.out.println(num);
        ser.shutdownNow();
    }
}

原理
继承方式：创建好线程对象后，调用start()方法启动线程，start()方法又调用start0()方法，start0()方法调用了run()方法，因为在自定义类型（子类中）重写了Thread类的run()方法，所以直接执行子类中重写后的run，我们重写是定义好的业务逻辑，就执行了。

实现方法：创建接口的实现类对象，这个对象是一个任务对象。创建线程对象，将任务封装到线程对象中，将任务对象当做参数床底个线程对象，线程对象在创建的过程中，连续调用两个int方法，之后，将任务对象作为线程对象的成员变量，赋值给线程。创建好线程对象后，调用start（）方法启动线程，start()方法又调用start0()方法，start0()方法调用了run方法，因为在初始化的时候，已经将任务对象封装进了线程对象中，所以此时是线程对象在调用线程了类中的run犯法，此时run犯法就要执行。判断任务对象不为null之后，任务对象调用接口中的run方法，因为接口的run方法已经被实现了；所以根据任务对象所属类型，调用任务对象所属类中重写过的run方法，执行重写过的方法。

在灵活性方面，继承方式的业务逻辑和线程对象绑定在一起，耦合度高，灵活性差；实现方式将任务队形和线程对象分开，耦合度低，灵活性强。

Thread类常用方法
getName（）获取线程的名称
setNmame(String name)设置线程名称
static Thread currentThread()获取当前线程对象
static sleep(long millis)让当前线程休眠指定的毫秒数
isDaemon()判读一个线程是否为守护线程
setDaemon(boolean bo)将一个线程是设置为守护线程
线程优先级
MAX_PRIORITY 最高优先级：10
MIN_PRIORITY 最低优先级：1
NORM_PRIORITY默认优先级：5
setPriority(int newPriority)设置线程优先级

线程的生命周期
线程是一个动态的概念，有创建的时候，也有运行和变化的时候，也有消亡的时候，从生到死就是现成的生命周期。分为新建、就绪、运行、阻塞、死亡五个阶段。
新建：线程对象创建出来之后，未start
就绪：线程start了，但是CPU没有来临
运行：正在运行的线程的状态
阻塞：线程主动休息、或者缺少一些执行所必须的资源，及时CPU来领也无法执行
死亡：线程完成了业务逻辑，或者出现异常被打断，或者线程被破坏
线程状态获取
getState()方法
NEW ：尚未start的线程
rUNNABLE:正在运行的线程
BLOCKED：等待锁对象
WAITING ：被wait()的线程的状态
TIMED_WAITING：有时限的等待
TERMINATED：线程死亡了
线程安全问题
某一段代码在操作一个数据的时候，还没操作完毕，CPU就切换到其他线程上，就会导致数据的不完整或者错误，这个时候我们就要来考虑线程的安全了。
同步代码块
让某段代码执行的时候，CPU不会切换到影响这段代码执行的代码上去
格式：

synchronized(//同步锁对象){
需要保证完整性的代码
}

效果：当CPU想要去执行同步代码块的时候，需要先获取到同步锁对象，获取之后就能执行同步代码快里面的内容；当CPU想要执行其他线程的是时候，是不会切换到具有相同通过锁对象的代码上
CPU执行完了当前代码块中的代码，会释放同步锁对象，CPU就可以运行到其他的县城上，执行其他代码。
同步方法
同步方法的格式：

修饰符【static】synchronized 返回值类型 防范名称（参数列表）{
需要保证同步的方法体
}

同步锁对象
非静态方法：同步锁对象是this
静态方法：同步方法所在类的字节码对象，类名.class
常见安全不安全线程
线程不安全的类型：StringBuilder 、ArrayList、HashMap
常见安全的类型：StringBuffer、Vector、Hashtable
死锁
假设有两个线程，两个线程想要继续执行，必须要用到对方现在占用的资源，这是两个线程都会卡死，也就成了个死锁
单例设计模式
单例设计模式就是，在某些情况下，设计就一个类，这个类有且仅有一个对象。
通过使用单例模式，可以节约系统的资源开销，避免共享资源的多重占用等优点。
设计原则
1.构造方法私有化
2.在类中创建好对象
3.在类中对外提供获取对象的方式
懒汉式书写

public synchronized class Alone {
  private Alone alone;

  private Alone() {

  }

  public Alone getInstance() {
      if (alone == null) {
          alone = new Alone();
      }
      return alone;
  }
}

线程池
创建步骤
1.获取线程池对象
2.创建人物对象
3.将任务提交到线程池中

获取线程对象
Executors：用于生成线程池的工具类，根据需求可以指定线程池中线程的数量
ExecutorService newFixedThreadPool(int nTHreads)创建一个线程池，线程数量由参数指定
ExecutorService newFixedThreadExecutor()创建一个只具有一条线程的线程池

创建任务对象
创建Runnable接口的实现类对象即可

将任务提交到线程池中
submit（Runnable task）将任务提交到线程池
shutdown（）结束线程池
shutdownNow（）结束线程池