线程创建的方式

1、什么是进程，什么是线程，协程进程与线程的区别和联系？
（1）进程是操作系统资源分配和管理的基本单位，而线程是处理器任务调度和执行的基本单位。一个进程里可以有多个线程，线程也被称为轻量级进程。
协程：又称为微线程，是一种用户态的轻量级线程（不是被操作系统所管理，而是完全由程序所控制），协程的上下文切换是由自己控制的，一个线程可以有多个协程。java中没有协程，Python和go语言支持。
区别
（1）进程之间的地址空间和资源是独立的，而同一线程共享本地进行的空间和资源
（2）一个进程奔溃之后，不会对其他进程产生影响，但是一个线程奔溃之后，整个进程都会死掉。
（3）线程执行开销比较小。

2、什么是并行，什么是并发
并发：同个时间段，多个任务在一个CPU中交替执行。
并行：在同一时刻，多个任务在多个CPU中同时执行。

3、什么是线程安全
（1）含义：指的是内存安全，堆是共享内存，可以被所有线程共享。
（2）当多个线程访问一个对象时，如果不需要加额外同步控制或者其他协调工作，调用这个对象的行为都可以获得正确的结果，那么这个对象就是线程安全的

4、线程的状态
NEW : 初始状态，线程被创建了，但是还没有调用start（）方法启动
RUNNABLE： 可运行状态，又可细分为就绪状态和运行中状态。线程调用了start（）方法启动之后。
BLOCKED： 阻塞状态。一个线程请求一个锁时，这个锁已经被其他线程占用了，这个线程就会被阻塞，阻塞时被动的
WAITING：等待状态，表示线程进入了等待状态，需要被其他线程显式的唤醒，等待是主动的。
TIMED-WAITING：限时等待状态。相对于等待状态，限时等待状态会等待一段时间之后，自动退出等待状态。
TERMINATED：终止状态。表示当前线程已经执行完毕结束了，或者发生了异常结束了。
**过程：**线程创建之后它处于NEW状态，调用了start（）方法之后开始运行，此时进入ready（）就绪状态，在线程获得了CPU时间片之后进行running运行状态。当线程执行了wait（）方法后进入了waiting等待状态，需要得到其他线程的通知才能返回到运行状态。而TIMED-WAITING相当于在waiting的基础上设置超时限制，比如sleep(long millis) wait(long millos)，当超过等待时间之后就会到runnable状态，当线程调用同步方法的时候，如果没有获得锁的情况下，就会进入blocked状态，线程在执行完RUNNABLE的run()方法之后就会进入到TERMINATED状态。

线程通信方式

进程通信方式

• 信号量：信号量是一个计数器，用于多进程对共享数据的访问，解决同步相关的问题并避免竞争条件
• 共享存储：多个进程可以访问同一块内存空间，需要使用信号量用来同步对共享存储的访问
• 管道通信：管道是用于连接一个读进程和一个写进程以实现它们之间通信的一个共享文件，pipe 文件
  • 匿名管道（Pipes）：用于具有亲缘关系的父子进程间或者兄弟进程之间的通信，只支持半双工通信
  • 命名管道（Names Pipes）：以磁盘文件的方式存在，可以实现本机任意两个进程通信，遵循 FIFO
• 消息队列：内核中存储消息的链表，由消息队列标识符标识，能在不同进程之间提供全双工通信，对比管道：
  • 匿名管道存在于内存中的文件；命名管道存在于实际的磁盘介质或者文件系统；消息队列存放在内核中，只有在内核重启（操作系统重启）或者显示地删除一个消息队列时，该消息队列才被真正删除
  • 读进程可以根据消息类型有选择地接收消息，而不像 FIFO 那样只能默认地接收

不同计算机之间的进程通信，需要通过网络，并遵守共同的协议，例如 HTTP

• 套接字：与其它通信机制不同的是，它可用于不同机器间的互相通信

5、创建线程的4种方式

• 继承Thread类
• 实现Runnable接口
• 实现Callable接口
• 使用Executors工具类创建线程池
  继承Thread类
  1、先写一个子类继承Thread类，然后重写run方法，run方法里写着线程要执行的业务逻辑
  2、创建一个自定义的线程子对象
  3、调用线程实例的start（）方法。

实现Runnable接口
1、写一个实现类MyRunnable实现Runnable接口，重写run方法
2、创建实现类的对象，将此对象作为参数传到Thread类的构造器中，创建了Thread类的对象
3、调用线程对象的start()方法

//1.创建一个类实现Runnable接口
class MyThread implements Runnable{
 //2.去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
    //do something...
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MyThread myThread = new MyThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的实列，相当于是未启动的线程，可创建多个。
        Thread t1 = new Thread(myThread);
        Thread t2 = new Thread(myThread);
        //5.通过Thread类的实列调用start()，也就是启动线程。
        t1.start();
        t2.start();
    }
}

实现Callable接口
1、创建一个类去实现Callable接口。重写call方法，里面写着线程执行的业务逻辑
2、创建接口实现类的对象。
3、把接口实现类的对象传递到FutureTask构造器中，创建FutureTask对象。
4、把FutureTask对象作为参数传递到Thread类的构造器中，创建thread对象，调用start方法。
5、如果需要返回值就调用get方法获取call方法的返回值
（future是一个接口，表示异步任务，用于获得线程执行后的返回值，futureTask表示一个异步运算的任务，FutureTask里面传入一个callable的具体实现类，可以对这个异步算法的任务结果进行等待获取）

public class MyThread implements Callable<Integer> {
    public Integer call() {
        return 123;
    }
}

public static void main(String[] args) throws ExecutionException, InterruptedException {
    MyThread myThread = new MyThread();
    FutureTask<Integer> ft = new FutureTask<>(myThread);
    Thread t1= new Thread(ft);
    t1.start();
    System.out.println(ft.get());
}

6、三种线程创建方式的比较
（1）实现接口的方法好，还是继承的方法好
实现接口比继承好，因为java只允许单继承，但可以实现多个接口，继承Thread类无法继承其他类，并且完全继承thread类开销过大。
（2）实现 Runnable 接口方式与 实现 Callable 接口方式区别？
callable有返回值，可以抛出异常，runnable都不行
run（）和start（）的区别
start用于线程启动，只能调用一次。run用于执行线程的运行时代码，能调用多次。

线程1，线程2，线程3，如何保证它们顺序执行
可以用线程类的join()方法在一个线程中启动另一个线程，另外一个线程完成该线程继续执行。为了确保三个线程的顺序你应该先启动最后一个(T3调用T2，T2调用T1)，这样T1就会先完成而T3最后完成。

7、为什么调用start可以执行run，不直接调用run方法
调用start方法会使线程进入运行状态，然后执行run方法，这是真正的多线程工作，而直接调用run方法就只是主线程中的一个普通方法的调用，并不是多线程工作。

8、线程切换

• java中，每个对象有且只有一个同步锁，调用synchronized方法获取了对象的锁。
• 当一个线程访问对象的同步方法或者同步代码块，其他线程不能访问该对象的同步方法或者对象代码块，但可以访问非同步的。
• t1.wait()，让当前线程进入阻塞状态，并且释放t1对象的锁，直到其他线程调用t1.notify()方法，当前线程才能被唤醒。如果没有释放锁，其他线程无法获得该对象的锁，就没有办法执行notify方法，就会导致死锁。
• wait()和notify方法必须出现在同步代码块中，他两是object的方法
• sleep（）：thread的静态方法，表示当前线程从运行状态进入阻塞状态，不会释放锁，休眠一段时间，进入就绪状态
• yield（）：thread的静态方法，表示当前线程从运行状态进入就绪状态，给其他线程
  **join:**比如在线程A中，调用线程B的join方法表示的意思就是：A等待B线程执行完毕后（释放CPU执行权），在继续执行。
  线程之间通信的方式
  

19、什么是死锁
当线程A持有独占锁a,尝试获得独占锁b，然后线程B持有独占锁b，并且尝试获得独占锁a,就会发生线程AB都由于互相持有对方需要的锁，而发生阻塞。
产生的条件：

• 互斥条件：该资源任意时刻只能被一个线程占用
• 请求与保持条件：一个进程因请求资源而被阻塞时，对已获得的资源不会释放。
• 不剥夺条件：一个线程已获得的资源，在没有使用完之前，不能强行剥夺
• 循环等待条件：若干进程形成一种头尾相接的循环等待资源关系
  要发生死锁，上边四个条件就必须都满足
  防止死锁可以采用的方法
  破坏产生死锁的必要条件
  （1）破坏请求与保持条件：一次性申请所有的资源
  （2）破坏不剥夺条件：占用部分资源的线程进一步申请其他资源时，如果申请不到的话，就主动释放它所占有的资源
  （3）破坏循环等待条件：靠按顺序来申请资源来预防。