java多线程基础学习归纳总结

短命女 2023-06-19 02:57 153阅读 0赞

# 一、基本概念： #

**1.1、什么是进程**

进程是资源分配的基本单位，是程序执行的一个实例。

程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入到进程就绪队列中，

进程调度器选中它的时候就会为它分配CPU执行时间，程序开始得到运行。

**1.2、什么是线程**

线程是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位。

一个进程可以由多个线程组成，同一个进程下的线程间共享该进程的资源，每个线程有自己的堆栈，和局部变量。

线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。

**1.3、两者的区别与优劣**

**区别：**

：线程与资源的分配无关，它属于某一个进程，并与进程内的其他线程共享进程的资源（全局变量、静态变量等数据）。

：每个进程都有自己一套独立的资源，供其内的所有线程共享。

**优劣：**

：创建一个线程的开销比创建一个进程要小很多，CPU切换一个线程的花费远比进程要小很多。

：线程之间的通信更方便，进程之间的通信需要以通信的方式（IPC)进行

：但是多进程程序更健壮，多线程程序只要有一个线程死掉，整个进程也死掉了，而一个进程死掉并不会对另外一个进程造成影响，因为进程有自己独立的地址空间。

# 二、生命周期 #

**java多线程状态图：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6cWFhYXNzcw_size_16_color_FFFFFF_t_70][]

**java多线程的五种状态：**

**2.1、新建状态(New)**

当程序通过new关键字来创建一个线程之后，例如：

Thread thread = new Thread("test");

此时线程处于新建状态，但已经有了相应的内存空间和其他资源 。

**2.2、就绪状态(Runnable)**

当调用了线程的start()方法之后，该线程处于就绪状态。Java虚拟机会为其创建方法调用栈和程序计数器，处于这个状态中的线程并没有开始运行，只是表示该线程可以运行了。至于该线程何时开始运行，取决于JVM里线程调度器的调度。

**2.3、运行状态(Running)**

如果处于就绪状态的线程获得了CPU执行权，开始执行run()方法的线程执行体，则该线程处于运行状态，只有处于就绪状态中的线程才有机会进入运行状态。

**2.4、阻塞状态(Blocked)**

在线程运行的过程中，出于某种原因，线程失去了CPU的执行权而进入了阻塞状态，当被阻塞线程的阻塞解除后就会进入就绪状态再次等待CPU的调度才有机会再进入运行状态。

根据阻塞产生的原因不同，阻塞状态又可以分为三种：

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

**同步阻塞** ： 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；

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

**2.5、终止状态(Dead)**

线程执行完了或因异常退出了run()方法，该线程结束生命周期。

# 三、实现方式 #

Thread类的中的三种构造方法：

Thread(String name)

Thread(Runnable target)

Thread(Runnable target,String name)

参数：target 称为被创建线程的目标对象。创建目标对象target的类负责实现 Runnable接口，给出该接口中run()方法的方法体。

**2.1、继承Thread方式**

定义一个线程类，它继承Thread类并重写其中的run()方法,此时初始化这个类的实例是taeget可以为null，用这种方法创建将不能再继承其他类。

public class MyThread extends Thread{
        @Override
        public void run() {
    
            for (int i =0;i<10;i++){
                //获取当前线程名
                System.out.println(getName()+":"+i);
            }
        }
        public static void main(String[] args) {
            Thread t = new MyThread();
            t.start();
        }
    }

**2.2、实现Runnable接口方式**

public class MyThread extends Thread{
        @Override
        public void run() { 
            
            for (int i =0;i<10;i++){
                //获取当前线程名
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
        public static void main(String[] args) {
            Thread t = new MyThread();
            t.start();
        }
    }

运行截图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6cWFhYXNzcw_size_16_color_FFFFFF_t_70 1][]

**2.3、Callable 方式**

public class CallableTest {
    
        public static void main(String[] args) {
    
            CallableDemo cd = new CallableDemo();
            // 执行 Callable 方式,需要 FutureTask 实现类的支持
            // FutureTask 实现类用于接收运算结果, FutureTask 是 Future 接口的实现类
            FutureTask<Integer> ft = new FutureTask<Integer>(cd);
            Thread t = new Thread(ft);
            t.start();
            try {
                System.out.println(ft.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
    
        }
        static class CallableDemo implements Callable<Integer>{
    
            @Override
            public Integer call() {
                int i =0;
                while (i<100){
                    i++;
                }
                return i;
            }
        }
    }

**2.4、三者的比较**

继承方式  
优点可直接this获取当前线程，缺点不能多继承；  
采用实现Runnable、Callable接口的方式  
优点：1、线程类只是实现了Runnable接口与Callable接口，还可以继承其他类。  
2、在这种方式下，多个线程可以共享一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，较好地体现了面向对象的思想。  
3、Callable方式有返回值

缺点：如果需要访问当前线程，则必须使用Thread.currentThread()方法。

# **四、常用方法** #

**4.1、Thread.currentThread()**

返回当前正在执行的线程对象的引用

**4.2、isAlive()**

测试当前线程是否在活动

**4.3、interrupt()**

若此时调用线程的interrupt()方法，将线程中断标记设置为true，处于阻塞状态，中断标记将被清除同时产生一个IntertuptedException异常，将异常放在适合的位置将会终止线程。

**4.4、isInterrupted()**

判断线程中段标记是否为true，默认为false，当调用线程的interrupt()方法时会**isInterrupted()** 返回true

**4.5、sleep(long millis)**

使当前执行的线程处于休眠状态(临时停止)，此时线程不会释放所拥有的锁。等到指定休眠时间过过后重新进入就绪状态。

**4.6、join(long millis)**

join方法的主要作用就是同步，它可以使得线程之间的并行执行变为串行执行。在A线程中调用了B线程的join()方法时，表示只有当B线程执行完毕时，A线程才能继续执行。

join方法中如果传入参数，则表示这样的意思：如果A线程中掉用B线程的join(10)，则表示A线程会等待B线程执行10毫秒，10毫秒过后，A、B线程并行执行。需要注意的是，jdk规定，join(0)的意思不是A线程等待B线程0秒，而是A线程等待B线程无限时间，直到B线程执行完毕，即join(0)等价于join()。(其实join()中调用的是join(0))

join方法必须在线程start方法调用之后调用才有意义。这个也很容易理解：如果一个线程都没有start，那它也就无法同步了。

**源码如下：**

public final void join() throws InterruptedException {
            join(0);
        }
        public final synchronized void join(long millis)
        throws InterruptedException {
            long base = System.currentTimeMillis();
            long now = 0;
    
            if (millis < 0) {
                throw new IllegalArgumentException("timeout value is negative");
            }
    
            if (millis == 0) {
                while (isAlive()) {
                    wait(0);
                }
            } else {
                while (isAlive()) {
                    long delay = millis - now;
                    if (delay <= 0) {
                        break;
                    }
                    wait(delay);
                    now = System.currentTimeMillis() - base;
                }
            }
        }

**4.7、yield()**

yield()：和sleep类似，让线程从“运行状态”到“就绪状态”，但是不会阻塞线程，只是让当前线程停一会儿，让同优先级的其他线程获得被执行的机会，但是不保证一定会被执行。yield和sleep一样不会释放同步锁。

# **五、线程同步** #

由于java的每个对象都有一个内置锁，当用synchronized关键字修饰方法时， 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。synchronized可以修饰方法和代码块，但是不能修饰构造器、成员变量等。

public class ThreadTTest {
        public static void main(String[] args) {
            Runnable r = new ThreadA();
            Thread a = new Thread(r, "thread-a");
            Thread b = new Thread(r, "thread-b");
            a.start();
            b.start();
        }
         static class ThreadA implements Runnable {
             @Override
             public synchronized void run() {
                 for (int i =0;i<10;i++){
                     System.out.println(Thread.currentThread().getName()+i);
                 }
    
             }
         }
    }

也可以用ReentrantLock（可重入锁）来实现，

import java.util.concurrent.locks.ReentrantLock;
    
    public class ThreadTTest {
        public static void main(String[] args) {
            Runnable r = new ThreadA();
            Thread a = new Thread(r, "thread-a");
            Thread b = new Thread(r, "thread-b");
            a.start();
            b.start();
        }
         static class ThreadA implements Runnable {
             private final ReentrantLock loc = new ReentrantLock();
             @Override
             public void run() {
                 loc.lock(); //加锁
                 try {
                     for (int i =0;i<10;i++){
                         System.out.println(Thread.currentThread().getName()+i);
                     }
                 }finally {
                     loc.unlock(); //解锁
                 }
             }
         }
    }

# 六、线程通信 #

Object类提供了**wait、notify、notifyAll**三个方法：

**wait()**：让当前线程放弃CPU、共享资源，处于等待阻塞状态，直到其他线程调用该同步监视器的notify(),notifyAll()方法来唤醒该线程，进入就绪状态。wait()会释放对当前线程的同步监视器的锁定。

：无时间参数的wait：一直等到，直到其他线程通知唤醒

：带时间参数的wait：等待指定时间后自动唤醒。

**notify()**：唤醒在此同步监视器上等待的单个线程。若监视器上有很多个线程等待，则任意唤醒一个。

**notifyAll()**：唤醒在此同步监视器上等待的所有线程。

Java.lang.Object提供的这三个方法只有在synchronized方法或代码块中才能使用，否则会报出java.lang.IllegalMonitorStateException异常

# **七、线程中断** #

当线程调用了yield、join、sleep等方法进入阻塞状态，若此时调用线程的interrupt()方法，将线程中断标记设置为true，处于阻塞状态，中断标记将被清除同时产生一个IntertuptedException异常，将异常放在适合的位置将会终止线程。

public class MyThread extends Thread{
        @Override
        public void run() {
            int i =0;
            while (!isInterrupted()){
                System.out.println(getName()+":"+i++);
            }
        }
        public static void main(String[] args) throws InterruptedException {
            Thread t = new MyThread();
            t.start();
            Thread.currentThread().sleep(10);
            System.out.println(t.isInterrupted());
            //设置线程中断标记为true
            t.interrupt();
            System.out.println(t.isInterrupted());
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6cWFhYXNzcw_size_16_color_FFFFFF_t_70 2][]

# 八、守护线程 #

Java的线程分为两种：用户线程和守护线程（后台线程），可以用isDaemon()方法来区别：如果返回false则为用户线程，否则为守护线程，JVM的垃圾回收线程就是典型的守护线程（后台线程）

后台线程的特征：如果前台线程都死亡，后台线程会自动死亡。

可以用setDaemon(true)将指定线程设定为后台线程。

public class MyThread extends Thread{
        @Override
        public void run() {
            int i =0;
            while (true){
                System.out.println(getName()+":"+i++);
            }
        }
        public static void main(String[] args) throws InterruptedException {
            Thread t = new MyThread();
            t.setDaemon(true);
            t.start();
            for (int i =0;i<10;i++){
                System.out.println(Thread.currentThread().getName()+i);
            }
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6cWFhYXNzcw_size_16_color_FFFFFF_t_70 3][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6cWFhYXNzcw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191207001812631.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6cWFhYXNzcw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6cWFhYXNzcw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191206221645471.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6cWFhYXNzcw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6cWFhYXNzcw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/201912070010521.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6cWFhYXNzcw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6cWFhYXNzcw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191207002151484.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6cWFhYXNzcw==,size_16,color_FFFFFF,t_70