面试笔记——多线程基础

线程与进程的区别

程序友指令和数据组成，要执行这些指令和数据，就必须将指令加载至CPU，数据加载到内存。
当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。
一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行
一个进程之内可以分为一到多个线程。
进程与线程的关系如图：

区别：

• 进程是正在运行程序的实例，进程中包含了线程，每个线程执行不同的任务
• 不同的进程使用不同的内存空间，在当前进程下的所有线程可以共享内存空间
• 线程更轻量，线程上下文切换成本一般上要比进程上下文切换低(上下文切换指的是从一个线程切换到另一个线程)

并行和并发的区别

针对单核CPU

单核CPU下线程实际还是串行执行的。
操作系统中有一个组件叫做任务调度器，将cpu的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于cpu在线程间（时间片很短）的切换非常快，人类感觉是同时运行的 。
总结为一句话就是： 微观串行，宏观并行 。
一般会将这种线程轮流使用CPU的做法称为并发（concurrent），如图：

针对多核CPU

每个核（core）都可以调度运行线程，这时候线程可以是并行的，如图，在时间片1时，线程1和线程2分别在不同核上并行执行指令：

区别：

• 并发（concurrent）是同一时间应对（dealing with）多件事情的能力
• 并行（parallel）是同一时间动手做（doing）多件事情的能力

创建线程的方式

共有四种方式可以创建线程，分别是：

• 继承Thread类
• 实现runnable接口
• 实现Callable接口
• 线程池创建线程

举例——通过Thread类：

public class MyThread extends Thread {
       @Override
       public void run() {
           System.out.println("MyThread...run...");
       }
   
       
       public static void main(String[] args) {
   
          // 创建MyThread对象
       MyThread t1 = new MyThread() ;
          MyThread t2 = new MyThread() ;
   
           // 调用start方法启动线程
       t1.start();
          t2.start();
       }
   }

举例——实现Runable接口：

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("MyRunnable...run...");
    }

    public static void main(String[] args) {

        // 创建MyRunnable对象
    MyRunnable mr = new MyRunnable();

        // 创建Thread对象
    Thread t1 = new Thread(mr);
       Thread t2 = new Thread(mr);

        // 调用start方法启动线程
    t1.start();
       t2.start();

    }
}

举例——Callable接口：

public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        return "ok";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建MyCallable对象
    MyCallable mc = new MyCallable() ;
        // 创建FutureTask
       FutureTask<String> ft = new FutureTask<String>(mc) ;
        // 创建Thread对象
    Thread t1 = new Thread(ft) ;
       Thread t2 = new Thread(ft) ;
        // 调用start方法启动线程
    t1.start();
        // 调用ft的get方法获取执行结果
    String result = ft.get();
        // 输出
    System.out.println(result);
    }
}

举例——线程池：

public class MyExecutors implements Runnable{

    @Override
    public void run() {
        System.out.println("MyRunnable...run...");
    }

    public static void main(String[] args) {

        // 创建线程池对象
    ExecutorService threadPool = Executors.newFixedThreadPool(3);
       threadPool.submit(new MyExecutors()) ;

        // 关闭线程池
    threadPool.shutdown();

    }

}

通过实现Runable和Callable接口创建线程的方式的区别：

• Runnable 接口run方法没有返回值；
• Callable接口call方法有返回值，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果；
• Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的异常只能在内部消化，不能继续上抛；

线程的 run()和 start()的区别：

• start(): 用来启动线程，通过该线程调用run方法执行run方法中所定义的逻辑代码。start方法只能被调用一次。
• run(): 封装了要被线程执行的代码，可以被调用多次。

线程的状态及状态之间的转换

参考Thread类中的State可得：

public enum State {

    //尚未启动的线程的线程状态
    NEW,
        
    //可运行线程的线程状态。
    RUNNABLE,
        
    //线程阻塞等待监视器锁的线程状态。
    BLOCKED,
     
    //等待线程的线程状态
    WAITING,
        
    //具有指定等待时间的等待线程的线程状态
    TIMED_WAITING,
        
    //已终止线程的线程状态。线程已完成执行
    TERMINATED;
}

状态之间的转换关系：

• 创建线程对象是新建状态
• 调用了start()方法转变为可执行状态
• 线程获取到了CPU的执行权，执行结束是终止状态
• 在可执行状态的过程中，如果没有获取CPU的执行权，可能会切换其他状态
  • 如果没有获取锁（synchronized或lock）进入阻塞状态，获得锁再切换为可执行状态
  • 如果线程调用了wait()方法进入等待状态，其他线程调用notify()唤醒后可切换为可执行状态
  • 如果线程调用了sleep(50)方法，进入计时等待状态，到时间后可切换为可执行状态

新建3个线程，如何保证它们的执行顺序

使用线程中的join方法（join()表示等待线程运行结束）
t.join() 阻塞调用此方法的线程进入timed_waiting，直到线程t执行完成后，此线程再继续执行。
如图：

notify()和 notifyAll()的区别

• notifyAll：唤醒所有 wait 的线程；
• notify：只随机唤醒一个 wait 线程；

java中wait和sleep方法的不同

共同点： wait() ，wait(long) 和 sleep(long) 的效果都是让当前线程暂时放弃 CPU 的使用权，进入阻塞状态；

不同点：

1. 方法归属不同
   • sleep(long) 是 Thread 的静态方法
   • 而 wait()，wait(long) 都是 Object 的成员方法，每个对象都有
2. 醒来时机不同
   • 执行 sleep(long) 和 wait(long) 的线程都会在等待相应毫秒后醒来
   • wait(long) 和 wait() 还可以被 notify 唤醒，wait() 如果不唤醒就一直等下去
   • 它们都可以被打断唤醒
3. 锁特性不同（重点）
   • wait 方法的调用必须先获取 wait 对象的锁，而 sleep 则无此限制
   • wait 方法执行后会释放对象锁，允许其它线程获得该对象锁（我放弃 cpu，但你们还可以用）
   • 而 sleep 如果在 synchronized 代码块中执行，并不会释放对象锁（我放弃 cpu，你们也用不了）

停止一个正在运行的线程

以下三种方式可以停止线程：

• 使用退出标志，使线程正常退出，也就是当run方法完成后线程终止（外部修改标记，使run()方法结束）
• 使用stop方法强行终止（不推荐，方法已作废）
• 使用interrupt方法中断线程
  • 打断阻塞的线程（ sleep，wait，join ）的线程，线程会抛出InterruptedException异常
  • 打断正常的线程，可以根据打断状态来标记是否退出线程

方式一：

public class InterruptType1 extends Thread {

    volatile boolean flag = false ;     // 线程执行的退出标记

    @Override
    public void run() {
        while(!flag) {
            System.out.println("MyThread...run...");
            try {
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {

        // 创建MyThread对象
        InterruptType1 t1 = new InterruptType1() ;
        t1.start();

        // 主线程休眠8秒
        Thread.sleep(8000);

        // 更改标记为true
        t1.flag = true ;

    }
}

方式二：

public class InterruptType2 extends Thread {

    volatile boolean flag = false ;     // 线程执行的退出标记

    @Override
    public void run() {
        while(!flag) {
            System.out.println("MyThread...run...");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {

        // 创建MyThread对象
        InterruptType2 t1 = new InterruptType2() ;
        t1.start();

        // 主线程休眠2秒
        Thread.sleep(6000);

        // 调用stop方法
        t1.stop();

    }
}

方式三：

public class InterruptType3 {

    public static void main(String[] args) throws InterruptedException {

        //1.打断阻塞的线程
        /*Thread t1 = new Thread(()->{
            System.out.println("t1 正在运行...");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t1");
        t1.start();
        Thread.sleep(500);
        t1.interrupt();
        System.out.println(t1.isInterrupted());*/


        //2.打断正常的线程
        Thread t2 = new Thread(()->{
            while(true) {
                Thread current = Thread.currentThread();
                boolean interrupted = current.isInterrupted();
                if(interrupted) {
                    System.out.println("打断状态："+interrupted);
                    break;
                }
            }
        }, "t2");
        t2.start();
        Thread.sleep(500);
        t2.interrupt();
    }
}