【JUC】Day1线程基础

线程和进程

加载到cpu，从内存读写数据，管理IO。而进程是由多个线程组成的。一个java程序默认有两个线程（main和GC）。同时线程里是指令流，将一条条指令交给CPU，各个线程处理不同的任务。同一个进程里的线程共享内存空间。上下文切换的成本比进程低。

• java可以开启线程吗？
  不能，thread.start底层是c++，java无法操作硬件。

并行和并发

并行是多个CPU同时运行，并发是多个线程使用一个CPU。
并发：

public static void main(String[] args) {
        FileReader.read(Constants.MP4_FULL_PATH);
        log.debug("do other things ...");
    }

并行：

public static void main(String[] args) {
        new Thread(() -> FileReader.read(Constants.MP4_FULL_PATH)).start();
        log.debug("do other things ...");
    }

并行效率比并发效率高吗？

在单核CPU下，如果有两个任务A、B，并发的情况是CPU先处理一部分A，再处理一部分B，反复交替。但无法实现并行。
在多核CPU下，可以实现真正的并行。但是否并行效率比并发高呢？
对于依赖性任务，如果任务之间存在强依赖性（例如需要等待前一个任务的结果），并行化可能导致资源浪费。
对于 I/O 密集型任务（如读写文件、网络请求），并行处理可能无法充分利用多核性能，反而导致资源争用。

线程运行原理

• 栈帧
  每个线程启动后，jvm为每个线程分配一块栈内存，每个栈由多个栈帧组成，每个线程对应一个活动栈帧。
• 上下文切换
  因为一些原因CPU不再执行当前线程，去执行其他线程。在上下文切换时，操作系统需要保存当前信息并恢复另一个线程的状态。状态包括：程序计数器（记录下一条指令的执行地址）、每个栈帧的信息（局部变量表、操作数栈、返回地址）

创建线程

继承Thread类

class ThreadDemo extends Thread{
    @Override
    public void run(){
        System.out.println("run...");
    }
    public static void main(String[] args) {
        ThreadDemo t=new ThreadDemo();
        t.start();
    }

}

缺点是一个类只能继承一个类，如果已经继承了一个类，就不能再继承Thread

Runable配合Thread

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

    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

一个类去实现这个runnable接口，重写run方法，再将这个类作为参数传入thread的构造器，创建thread实例后start

Callable结合FutureTask

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        return 1;
    }

    public static void main(String[] args) {
        MyCallable myCallable = new MyCallable();
        FutureTask futureTask = new FutureTask<>(myCallable);
        Thread thread = new Thread(futureTask);
        thread.start();
    }
}

和runnable的区别:call方法有返回值而且可以抛出异常。并且用FutureTask包装，FutureTask实现Runnable接口

线程池创建

public class Task implements Runnable{
    @Override
    public void run() {
        System.out.println("执行任务");
    }

    public static void main(String[] args) {
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 100; i++) {
            //提交100次任务
            executorService.submit(new Task());
        }
        //关闭线程池
        executorService.shutdown();
    }
}

主要线程方法

• start
  start只能被调用一次，使线程进入就绪状态，运行run中的代码

• run
  可以被多次调用，在线程启动后调用

• sleep
  让当前线程休眠一会（进入阻塞态）再执行，同时将CPU时间片分给其他线程

• join
  等待这个线程结束，再向下执行

 public static void task() throws InterruptedException {
        Thread thread = new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            r=10;
        });
        thread.start();
        thread.join();//等待这个线程结束，再向下执行
        System.out.println(r);
    }

• interrupt
  打断sleep\join\wait的线程（阻塞状态）

public static void task() throws InterruptedException {
        Thread thread = new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        thread.start();
        Thread.sleep(500);
        thread.interrupt();
        System.out.println(thread.isInterrupted());//返回false，说明sleep被打断
    }

打断运行状态的线程

public static void task2() throws InterruptedException {
        Thread thread = new Thread(()->{
            while (true) {
                boolean interrupted = Thread.currentThread().isInterrupted();
                if(interrupted){
                System.out.println(interrupted);//返回true，被打断
                break;
            }}
        });
        thread.start();
        Thread.sleep(500);
        thread.interrupt();
    }