java面试笔记五：线程、进程、以及协程，java多线程实现方式，java线程常见状态

java面试笔记五：线程、进程、以及协程

进程、线程、协程

1. 线程，协程，进程的关系

进程：本质上是一个独立执行的程序，进程是操作系统进行资源分配和调度的基本概念，操作系统进行资源分配和调度的一个独立单位。

线程：是操作系统能够进行运算调度的最小单位，它包含在进程中，是进程的实际操作单位，一个进程可以并发多个线程，每个线程执行的任务不同，切换受系统控制，一个进程的所有线程共享进程的公共资源。

协程：又称为微线程，是一种用户态的轻量级线程，协程不像线程和进程那样需要系统内核的上下文切换，协程的上下文由用户决定，有自己的上下文，一个线程可以有多个协程，线程和进程是同步机制的，而协程是异步的。java原生语法没有实现协程，目前python、lua、Go支持协程。

cpu上真正运行的是线程。

2. 协程对于多线程有什么优缺点？

优点：

1、非常快速的进行上下文切换，不用系统内核的上下文切换，减小开销。

2、单线程即可实现高并发，单核cpu可以支持上万的协程。

3、由于只有一个线程，也不存在同时写变量的冲突，在协程中控制共享资源不需要加锁。

缺点：

1、协程无法利用多核资源，本质也是一个单线程

2、协程需要进程配合才能运行在多cpu上，

3、目前java没有成熟的第三方库，存在风险。

4、调试bug存在难度，不利于发现问题。

并发和并行

1. 并发和并行的区别

并发：一台处理器上同时处理任务，这个同是是通过划分cpu处理的时间段，交替执行多个任务的。不是真正意义上的同时。

并行：多个cpu上同时处理多个任务，一个cpu执行一个进程，另一个cpu可以执行另一个进程，两个进程互不抢占资源，可以同时进行。

并发指在一段时间内处理多个任务，并行指同一时刻，多个任务同时执行。

java实现多线程有几种方式？有什么不同？

1. 继承Thread

继承Thread,然后重写里面的run方法，创建实例，执行start

优点：

1、代码编写简单，直接操作。

缺点：

1、没有返回值，继承一个类后没法继承其他类，扩展比较差。

public class ThreadDemo1 extends Thread{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("继承Thread实现多线程"+Thread.currentThread().getName());
    }
}

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThreadDemo1 threadDemo1=new ThreadDemo1();
        threadDemo1.setName("demo1");
        threadDemo1.start();
        System.out.println("主线程名称"+Thread.currentThread().getName());
    }

}

2. 实现Runable

自定义类实现Runnable,实现里面的run方法，创建Thread类，使用Runnable接口的实现对象，作为参数传递给Thread对象，调用start方法。

优点:

​ 线程类可以实现多个接口，可以再继承一个类。

缺点：

​ 没有返回值，不能直接启动，需要通过构造一个Thread实例传递进去启动。

public class ThreadDemo2 implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("通过Runnable实现多线程，名称："+Thread.currentThread().getName());
    }

}

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //ThreadDemo1 threadDemo1=new ThreadDemo1();
        ThreadDemo2 threadDemo2 =new ThreadDemo2();
        Thread thread =new Thread(threadDemo2);
        thread.setName("demo2");
        thread.start();
        System.out.println("主线程名称"+Thread.currentThread().getName());
    }

}

使用Lambda表达式创建匿名内部类线程

public class Main {

    public static void main(String[] args) {

        //匿名内部类使用Lambda表达式

        Thread thread2=new Thread(()->{
            System.out.println("通过Runnable实现多线程，名称"+Thread.currentThread().getName());
        });
        thread2.setName("demo2,Lambda");
        thread2.start();
        System.out.println("主线程名称"+Thread.currentThread().getName());
    }

}

3. 通过Callable方式实现

创建Callable接口的实现类，并实现call方法。结合FutureTask类包装Callable对象，实现多线程。

优点：

​ 有返回值，扩展性也高

缺点：jdk5之后才支持，需要重写call方法，结合多个类比如：FutureTask和Thread类

public class Main {

    public static void main(String[] args) {



        //MyTask myTask=new MyTask();
        //futureTask继承了Runnable,可以放在Thread中启动
        //FutureTask<Object> futureTask=new FutureTask<Object>(myTask);
        Thread thread3=new Thread(futureTask);
        thread3.setName("demo3");
        thread3.start();
        System.out.println("主线程名称"+Thread.currentThread().getName());
        //get()可以设置超时时间，超过多少时间就报异常。
        try {
            System.out.println((String)futureTask.get());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            //阻塞等待中被中断，	则抛出
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            //执行过程中，发送异常被抛出
            e.printStackTrace();
        }

    }

}

public class MyTask implements Callable<Object>{

    @Override
    public Object call() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("通过Callable实现多线程，名称："+Thread.currentThread().getName());

        return "这是返回值";
    }
}

使用Lambda表达式

public class Main {

    public static void main(String[] args) {



        //使用lambda
        FutureTask<Object> futureTask=new FutureTask<Object>(()->{
            System.out.println("通过Callable实现多线程，名称："+Thread.currentThread().getName());
            return "使用lambda";
        });
        //MyTask myTask=new MyTask();
        //futureTask继承了Runnable,可以放在Thread中启动
        //FutureTask<Object> futureTask=new FutureTask<Object>(myTask);
        Thread thread3=new Thread(futureTask);
        thread3.setName("demo3");
        thread3.start();
        System.out.println("主线程名称"+Thread.currentThread().getName());
        //get()可以设置超时时间，超过多少时间就报异常。
        try {
            System.out.println((String)futureTask.get());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            //阻塞等待中被中断，	则抛出
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            //执行过程中，发送异常被抛出
            e.printStackTrace();
        }

    }

}

4. 通过线程池创建线程

自定义Runnable接口，实现run方法，创建线程池，调用执行方法传入对象。

优点：安全性能高，复用线程

缺点：jdk5才有，需要结合Runnable进行使用。

public class Main2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		ExecutorService executorService=Executors.newFixedThreadPool(3);
		for(int i=0;i<10;i++) {
			executorService.execute(new ThreadDemo4());
		}
		System.out.println("主线程名称"+Thread.currentThread().getName());

		//关闭线程池
		executorService.shutdown();
	}

}

public class ThreadDemo4 implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("通过线程池+Runnable实现多线程，名称："+Thread.currentThread().getName());

    }


}

一般常用的有Runnable和第四种线程池+Runnable,简单方便扩展，和高性能(池化思想） 。

java线程常见的基本状态

1. java线程常见的基本状态有哪些？

jdk线程状态分6种，jvm里面9种，我们一般说jdk的线程状态

常见5种状态：

创建：（new）生成线程对象，但是并没有调用该对象的start()，new Thread()

就绪：（Runnable)当调用start()方法，线程就进入就绪状态，但是此刻线程调度还没把该线程设置为当前线程，就没有获得cpu使用权。如果线程运行后，从等待或者睡眠中回过来后，也会进入就绪状态。其实就绪就是进入了获取cpu的等待队列。

运行：（Running)获得cpu使用权，开始运行里面的逻辑。

阻塞：（Blocked)(wait,TIMED_WAITING):

​ 等待阻塞：进入该状态的的线程需要等待其他线程作出一定的动作，（通知或中断），这种状态的话cpu 不会分配过来，他们需要被唤醒，可能也会无限等待下去，比如调用wait(状态就会变成wait状态)，也可能通过调用sleep(状态就会变成TIMED_WAITING)，join或者发出IO请求，阻塞结束后，线程重新进入就绪状态。

​ 同步阻塞：线程在获取Synchronized同步锁失败，锁被其他线程占用，它就会进入同步阻塞状态。

​ 备注：

​ 等待：（WAITING）进入该状态的线程需要等待其他线程做出一些特定动作，（通知或中断)

​ 超时等待：（TIMED_WAITING)该状态不同于WAITING,它可以在指定的时间后自行返回。

死亡：（TERMINATED)一个线程run方法执行结束，该线程就死亡了，死亡后的线程不能进入就绪状态。

2. 画一下线程基本状态转换图

3. 多线程业务场景？

1、异步任务：用户注册，记录日志

2、定期备份日志，备份数据库

3、分布式计算：Hadoop处理任务，mapreduce，master-work(单机单进程)

4、服务器编程：Socket网络编程，一个连接一个线程。

4. 举例几个线程不安全的数据结构

HashMap,ArrayList,LinkedList

5. java中有哪些方法保证线程安全？

1、加锁，Synchronized或者reentrantLock

2、使用volatile声明变量，轻量级同步，不能保证原子性。

3、使用线程安全的安全类（原子类，并发容器，同步容器）ConcurrentHashMap,CopyOnWriteArrayList等。原子类（Atomicxxx）ThreadLocal本地私有变量/信号量Semaphore等。

6. 了解Volatile关键字，解释一下，和Synchronized有多大区别

Volatile是轻量级的Synchronized，保证了共享变量的可见性，被Volatile修饰的变量如果值发生了变化，其他线程立刻可见，避免出现脏读现象。

Volatile：保证了可见性，但是不能保证原子性。

Synchronized：保证可见性，保证原子性。

使用场景：

1、不能修饰写入操作，依赖当前值的变量，比如Num++,num=num+1,不是原子操作，看起来是，但是jvm内部不是。

2、由于禁止了指令重排，所以JVM相关的优化没了，效率会偏弱。

volatile为什么不能保证原子性

什么是原子性

7. 为什么会出现脏读？

JAVA内存模型简称：JMM

JMM规定所有变量存在主内存，每个线程有自己的工作内存。线程对变量的操作都是在工作内存中进行的，不能直接对主内存进行操作。

使用Volatile修改的变量：

​ 每次读取前必须是主内存中最新的值。

​ 每次写入需要立刻写到主内存中。

Volatile关键字修饰的变量随时看到的自己最新的值，加入线程a修改了值，线程b立刻可以看到。

8. 解释一下指令重排

指令重排分两类：编译器重排，和运行时重新排序

JVM在编译java代码或者cpu执行jvm字节码时，对现有的指令进行重新排序，主要目的是优化运行效率。（不会改变程序执行结果）‘

虽然指令排序会提高效率，但是多线程可能会影响结果，可以通过内存屏障解决。

内存屏障：是屏障指令，使cpu对屏障指令之前和之后的内存操作执行结果进行对比的一种约束。

9. 知道happen-before吗？能否简单解释一下

先行发生原则：Volatile的内存可见性就体现了这一原则。

//线程a

int j=1;

//线程b

int k=j;

//线程c

int j=2;

八大原则：

​ 1、程序次序原则

​ 2、管程锁定原则

​ 3、Volatile变量规则

​ 4、线程启动规则

​ 5、线程中断规则

​ 6、线程终止规则

​ 7、对象终结规则

​ 8、传递性