【并发编程】线程的基础知识篇-阿里云开发者社区

【并发编程】线程的基础知识篇

2023-05-24 77

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 【并发编程】线程的基础知识篇

1.进程与线程的区别

（1）什么是进程和线程

**进程：**是系统进行分配和资源管理的最小单位。
**线程：**进程的一个执行单元，是进程内调度的实体，CPU调度和分派的最小单位，是程序执行的最小单位。

（2）线程与进程的区别

进程有自己独立的地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据来维护代码块、堆栈段和数据段。
线程是共享程序中的数据，使用相同的地址空间，因此CPU切换一个线程的花费远比进程小。
线程之间通信更方便，同一进程下线程共享全局变量、静态变量等数据，而进程之间通信以通信方式进行。

2.线程的状态相互转换

（1）线程的六种状态

**新线程（NEW）：**新创建一个线程对象，但还没有调用start()方法。
**运行（RUNNABLE）：**处于可运行状态的线程正在JVM中执行，但它可能正在等待来自操作系统中的其他资源，例如处理器。
**阻塞（BLOCKED）：**线程阻塞于synchronized锁，等待获取synchronized锁的状态的线程。
**等待（WAITINT）：**obj调用wait()、join()等方法表示该线程进入等待状态，等待其他线程操作。
**超时等待（TIME_WAITING）：**obj.wait(时间参数)，Thread.join()，该状态的线程不同于WAITING，假如没有唤醒操作，它可以在指定时间内自行到RUNNABLE状态。
**终止（TERMINATED）：**表示该线程已经执行完毕，死亡状态。

（2）线程状态验证

RUNNABLE状态

public static void main(String[] args) {
      new Thread(()->{
          try {
              System.in.read();
          } catch (IOException e) {
              e.printStackTrace();
          }
      }).start();
}

BLOCKED和TIME_WAITING状态

public static void main(String[] args) {
        Object obj = new Object();
        new Thread(()->{![在这里插入图片描述](https://ucc.alicdn.com/images/user-upload-01/c22e0fb0dac14470ac4867c266bf6a7d.jpeg#pic_center)
            synchronized (obj){
                try {
                    //当线程拿到锁，无限睡眠，不释放锁
                    System.out.println("线程1拿到锁");
                    Thread.sleep(100000000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(()->{
            synchronized (obj){
                //线程2模拟拿不到锁
                System.out.println("线程2拿到锁");
            }
        }).start();
    }

WAITING状态

public static void main(String[] args) {
        Object obj = new Object();
        new Thread(()->{
            synchronized (obj){
                try {
                    //获取锁对象调用wait()让其进入等待状态
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

（3）线程的状态转换

3.创建线程的方式

（1）继承Thread类重写run()方法

public class MyThread extends Thread {
    @Override
    public void run(){
        System.out.println("线程运行");
    }
}

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

（2）实现Runnable接口重写run()方法

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

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

（3）实现Callable接口重写call()方法

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("线程运行");
        return 1;
    }
}

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

4.线程的挂起和恢复

（1）什么是线程的挂起

线程的挂起操作实质上就是使线程进入“非可执行”的状态下，在这个状态下CPU不会分给线程时间片，进入这个状态可以用来暂停一个线程的运行。

当线程挂起后，可以通过重新唤醒线程来使之回复运行。

（2）如何挂起线程

被废弃的方法

thread.suspend()该方法不会释放线程所占的资源。如果使用该方法将某个线程挂起，则可能会使其他等待资源的线程死锁。
thread.resume()方法本身并无问题，但是不能独立于suspend()方法存在。

JDK新的挂起唤醒方法

wait()暂停执行、放弃已经获得的锁、进入等待状态。
notify()随机唤醒一个在等待的线程。

notifyAll()唤醒所有在等待锁的线程，自行抢占CPU资源。

（3）suspend()、resume()案例

public class SuspendDemo implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"执行run()方法，调用suspend()方法之前");
        /**
         * 线程挂起（废弃的方法）
         */
        Thread.currentThread().suspend();
        System.out.println(Thread.currentThread().getName()+"执行run()方法，调用suspend()方法之后");
    }
}

public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new SuspendDemo());
    thread.start();
    /**
      * 对主线程进行休眠，以防目标线程先执行了唤醒操作，在执行挂起操作
      */
    Thread.sleep(3000L);
    thread.resume();
}

注意：suspend()挂起时，不会释放锁资源，会发生死锁，如果主线程不休眠很容易让线程先调用唤醒，从而让线程一直处在挂起的状态。

（4）wait()、notify()案例

public class WaitDemo implements Runnable{
    private static Object object = new Object();
    @Override
    public void run() {
        synchronized (object){
            try {
                System.out.println(Thread.currentThread().getName()+"获取锁资源");
                object.wait();
                System.out.println(Thread.currentThread().getName()+"执行业务逻辑");
                System.out.println(Thread.currentThread().getName()+"释放锁资源");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public static void main(String[] args) throws InterruptedException {
    Thread thread1 = new Thread(new WaitDemo2(),"线程1");
    thread1.start();
    Thread.sleep(3000L);
    synchronized (object){
        object.notify();
    }
}

5.线程的中断操作

（1）stop()废弃方法，开发中不要使用，因为一旦调用，线程就会立刻停止，因此有可能会引发线程安全性问题。

public class InterruptedDemo extends Thread{
    private int i = 0;
    private int j = 0;
    @Override
    public void run() {
        i++;
        try {
            Thread.sleep(2000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        j++;
    }
    public void printf(){
        System.out.println("i:"+i);
        System.out.println("j:"+j);
    }
}

public static void main(String[] args) throws InterruptedException {
    InterruptedDemo thread1 = new InterruptedDemo();
    thread1.start();
    Thread.sleep(1000L);
    thread1.stop();
    thread1.printf();
}

（2）Thread.interrupt()方法，改变线程终止的标识，默认是false，线程执行，调用interrupt()方法标识改成true，线程停止执行。

public class InterruptedDemo extends Thread{
    @Override
    public void run() {
        System.out.println("线程终止标识："+Thread.currentThread().isInterrupted());
       while (!Thread.currentThread().isInterrupted()){
           System.out.println("业务逻辑执行");
       }
        System.out.println("线程终止标识："+Thread.currentThread().isInterrupted());
    }
}

public static void main(String[] args) throws InterruptedException {
    InterruptedDemo thread1 = new InterruptedDemo();
    thread1.start();
    Thread.sleep(1);
    thread1.interrupt();
}

（3）自定义标识，通过判断来终止线程执行

public class InterruptedDemo extends Thread{
    //注意这里一定要加上volatile，防止指令重排
    private static volatile boolean FLAG = true;
    @Override
    public void run() {
        System.out.println("线程执行标识："+FLAG);
       while (FLAG){
           System.out.println("业务逻辑执行");
       }
        System.out.println("线程执行标识："+FLAG);
    }
}

public static void main(String[] args) throws InterruptedException {
    InterruptedDemo thread1 = new InterruptedDemo();
    thread1.start();
    Thread.sleep(1);
    FLAG = false;
}

6.线程的优先级

线程的优先级告诉程序该线程的重要程度有多大，如果有大量线程被堵塞，都在等待运行，程序会尽可能的先运行优先级大的那个线程。但是这并表示优先级低的线程不会先运行。若线程的优先级较低，只不过表示它被允许运行的机会小一些。

线程的优先级设置可以为1-10的任意数值，1的优先级最小，10的优先级最大，Thread类中定义了三个线程的优先级，MIN_PRIORITY(1)、NORM_PRIORITY(5)、MAX_PRIORITY(10)，一般情况下是这几个常量值，不建议自行设置其他值。

不同平台，对线程的优先级的支持不同。不能过度依赖线程的优先级。

线程优先级用处：需要快速处理的任务，设置高的优先级，不是很急的任务，设置低的优先级慢慢处理。

//setPrioity(num),设置最大优先级
thread.setPriority(Thread.MAX_PRIORITY);

线程优先级测试demo

public class PriorityDemo implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println(Thread.currentThread().getName()+":运行");
        }
    }
    public static void main(String[] args) {
        Thread thread1 = new Thread(new PriorityDemo(),"线程1");
        Thread thread2 = new Thread(new PriorityDemo(),"线程2");
        //设置线程1的优先级最大
        thread1.setPriority(Thread.MAX_PRIORITY);
        //设置线程2的优先级最小
        thread2.setPriority(Thread.MIN_PRIORITY);
        thread1.start();
        thread2.start();
    }
}

7.守护线程

线程分类

用户线程：用户自己new Thread的线程就是用户线程。
守护线程：任何一个守护线程都是整个程序中所有用户线程的守护者，只要有活着的用户线程，守护线程就活着。当JVM实例中最后一个非守护线程结束时，也随JVM一起退出。

守护线程的用处：jvm垃圾清理线程、主线程。
建议：尽量少使用守护线程，因其不可控不要在守护线程里去进行读写操作、执行计算逻辑
守护线程demo

public class DaemonDemo implements Runnable {
    @Override
    public void run() {
        while(true){
            System.out.println(Thread.currentThread().getName());
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new DaemonDemo(),"线程1");
        //设置为守护线程
        thread1.setDaemon(true);
        thread1.start();
        Thread.sleep(2000L);
    }
}

【并发编程】线程的基础知识篇

1.进程与线程的区别

2.线程的状态相互转换

3.创建线程的方式

4.线程的挂起和恢复

5.线程的中断操作

6.线程的优先级

7.守护线程

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【并发编程】线程的基础知识篇

1.进程与线程的区别

2.线程的状态相互转换

3.创建线程的方式

4.线程的挂起和恢复

5.线程的中断操作

6.线程的优先级

7.守护线程

热门文章

最新文章

相关电子书