线程基础（1）-CSDN博客

本文链接：https://blog.csdn.net/qq_44502765/article/details/114649552

线程基础

进程与线程
- - - 进程
    - 线程
进程的状态
线程的状态
创建线程的方式

进程与线程

进程

进程：是系统进行分配和管理资源的基本单位。
进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段，这种操作非常昂贵。

线程

线程：进程的一个执行单元，是进程内调度的实体、是CPU调度和分派的基本单位，是比进程更小的独立运行的基本单位。线程也被称为轻量级进程,线程是程序执行的最小单位。
线程是共享进程中的数据的，使用相同的地址空间，因此CPU切换一个线程的花费远比进程要小很多，同时创建一个线程的开销也比进程要小很多。
一个程序至少一个进程，一个进程至少一个线程。
线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，而进程之间的通信需要以通信的方式进行。
多进程程序更健壮，进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。
线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，所以可能一个线程出现问题，进而导致整个程序出现问题。

进程的状态

创建状态：由进程申请一个空包PCB，并向PCB中填写用于控制和管理进程的信息，然后为该进程分配运行时所必须的资源。
就绪状态：指进程已处于准备好运行的状态，即进程已分配到除CPU以外的所有必要资源后，只要再获得CPU，便可立即执行。如果系统中有许多处于就绪状态的进程，将它们按照一定策略排成一个队列，称为就绪队列。
执行状态：指进程已获得CPU，其程序正在执行的状态。
阻塞状态：指正在执行的进程由于发生某事件（如I/O请求、申请缓冲区失败等）暂时无法继续执行的状态，即进程的执行收到阻塞。
终止状态：等待操作系统进行善后处理，最后将其PCB清零，并将PCB空间返还系统。

线程的状态

初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
运行(RUNNABLE):处于可运行状态的线程正在JVM中执行，但它可能正在等待来自操作系统的其他资源，例如处理器。
阻塞(BLOCKED)：线程阻塞于synchronized锁，等待获取synchronized锁的状态。
等待(WAITING)：Object.wait()、join()、 LockSupport.park(),进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
超时等待(TIME_WAITING)：Object.wait(long)、Thread.join()、LockSupport.parkNanos()、LockSupport.parkUntil，该状态不同于WAITING，它可以在指定的时间内自行返回。
终止(TERMINATED)：表示该线程已经执行完毕。

创建线程的方式

1.继承Thread，并重写父类的run方法

public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.setName("线程demo");
        myThread.start();
    }
}

2.实现Runable接口，并实现run方法

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

    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.setName("runnable demo thread");
        thread.start();
        //thread.run();
    }
}

多选择第二种，java只允许单继承，增加程序的健壮性，代码可以共享，代码和数据独立。

调用thread.run()；时，不会启动一个线程处理，依旧在主程序里，输出的是 main，是相应当前的线程的名字。

3.实现Callable接口

/**
 * 实现callable接口
 */
public class MyCallable implements Callable {
    @Override
    public Integer call() throws Exception {
        int sum = 0;

        for (int i = 0; i < 100; i++) {
            sum+=1;
        }
        return sum;
    }

    public static void main(String[] args) {
        Callable<Integer> callable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask(callable);
        Thread thread = new Thread(futureTask);
        thread.setName("callableThread");
        thread.start();

        //接收线程运算后的结果

        try {
            Integer sum = futureTask.get();
            System.out.println(sum);

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

继承类与实现类的区别

线程类继承自Thread 则不能再继承其他类，而Runnable/Callable接口可以。
线程类继承自Thread 对于Runnable/Callable来说，使用线程类内部的方法方便一些。
实现Runnable接口的线程类的多个线程可以更加方便的访问同一变量，而Thread类则需要内部类进行代替。

Runnable和Callable的区别:

Runnable规定的方法是run()，Callable规定的方法是call()。
Runnable的任务是不能返回值的，Callable的任务执行后可返回值。
run()方法不能抛出异常，call()方法可抛出异常。
Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其他线程执行的任务。
运行Callable任务可拿到一个Future对象，Future表示异步计算的结果。提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象了解任务的执行情况，可取消任务的执行，还可以获取任务执行的结果。

4.使用匿名内部类

/**
 * 匿名内部类的方式
 */
public class MyThread {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        thread.start();
    }
}

5.Lambda表达式方法创建

public class LambdaThread {

    public static void main(String[] args) {
        new Thread(()->{
            System.out.println(Thread.currentThread().getName());
        }).start();
    }

}

6.通过线程池创建

/**
 * 通过线程池创建线程
 * 创建之后程序不会停止
 */
public class ThreadPool {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(()->{
            System.out.println(Thread.currentThread().getName());
        });
        //还是实现的Runnable
		//executorService.execute(new Runnable() {
         //   @Override
         //   public void run() {
        //        //其他操作
        //    }
       // });
    }

}