java_base:线程

1.线程与进程的区别：

进程：进程是操作系统资源分配的最小单元，一个进程可以包含多个线程。
线程：线程是程序执行的最小单元。

2.创建线程的三种方式：

2.1 继承Thread类

创建一个MyThread类继承Thread类，重写run方法

public class MyThread extends Thread {
    @Override
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println("run :"+i+" "+currentThread()+"   "+getName());
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

调用start()方法

public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        myThread.start();

        MyThread myThread1 = new MyThread();
        myThread1.start();
        for(int i=0;i<10;i++){
            System.out.println("main:"+i);
            Thread.sleep(10);
        }
    }

2.2实现Runnable接口

写一个RunnableImpl类实现Runnable接口，并重写run方法

public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            System.out.println("runnable:"+i+Thread.currentThread().getName());
        }
    }
}

调用start()方法

public static void main(String[] args) {
        RunnableImpl runnable = new RunnableImpl();
        Thread t = new Thread(runnable);
        t.start();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<10;i++){
                    System.out.println("runnable1:"+i+Thread.currentThread().getName());
                }
            }
        });
        t1.start();
        for (int i=0;i<10;i++){
            System.out.println("main:"+i+Thread.currentThread().getName());
        }
    }

2.3实现Callable接口

写一个类来实现Callable接口，重写Call方法

public class ThreadDemo implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}

main()方法

public class CallableTest {
    public static void main(String[] args) {
        ThreadDemo t = new ThreadDemo();
        FutureTask<Integer> result = new FutureTask<>(t);
        new Thread(result).start();
        Integer sum;
        try {
            sum = result.get();
            System.out.println("-----------------------------");
            System.out.println(sum);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

3.线程直接调用run方法和start方法的区别

直接调用run方法，也可以运行，相当于队列先进先出一样要按照顺序执行，
调用start()方法才是正确启动多线程的方式

class MyThread extends Thread{
    private String name;
    public MyThread (String name){
        this.name=name;
    }
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println(this.name+"="+i);
        }
    }
}
public class ThreadTest3 {
    public static void main(String[] args) {
        MyThread t1=new MyThread("线程1");
        MyThread t2=new MyThread("线程2");
        MyThread t3=new MyThread("线程3");
        t1.run();
        t2.run();
        t3.run();//只是顺序执行，不是多线程    
    
        t1.start();
        t2.start();
        t3.start();//调用Thread类的start方法才是正确启动多线程的方式
    }
}

4.线程的状态

4.1新建状态:

使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。

4.2就绪状态:

当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中。

4.3运行状态:

如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。

4.4阻塞状态:

如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。

4.4.1等待阻塞

运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。

4.4.2同步阻塞

线程在获取 synchronized同步锁失败(因为同步锁被其他线程占用)。

4.4.3其他阻塞

通过调用线程的 sleep() 或 join() 发出了 I/O请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

4.5死亡状态:

一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

5.死锁

死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。死锁的发生必须满足以下四个条件：
1.互斥条件
2.请求与保持条件
3.不剥夺条件
4.循环等待条件