线程介绍1.线程是啥 2、为啥使用多线程 3、线程优先级 4、线程状态 5、守护线程Daemon线程

最新推荐文章于 2024-04-10 20:05:03 发布

厚积薄发，积少成多

最新推荐文章于 2024-04-10 20:05:03 发布

阅读量155

点赞数

分类专栏：并发编程艺术

本文链接：https://blog.csdn.net/weixin_42546729/article/details/114047920

版权

并发编程艺术专栏收录该内容

14 篇文章 1 订阅

订阅专栏

1.线程是啥

现代操作系统在运行一个程序时，会为其创建一个进程。例如，启动一个Java程序，操作系统就会创建一个Java进程。现代操作系统调度的最小单元是线程，也叫轻量级进程(Light Weight Process)，在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。处理器在这些线程上高速切换，让使用者感觉到这些线程在同时执行。

[4] Signal Dispatcher // 分发处理发送给JVM信号的线程

[3] Finalizer // 调用对象finalize方法的线程

[2] Reference Handler // 清除Reference的线程

[1] main

// main线程，用户程序入口

[5] Monitor Ctrl-Break
[4] Signal Dispatcher
[3] Finalizer
[2] Reference Handler
[1] main

2、为啥使用多线程

1.更多的处理核心

2.更快的响应速度

3.更好的编程模型

Java为多线程编程提供了良好、考究并且一致的编程模型，使开发人员能够更加专注于问题的解决，即为所遇到的问题建立合适的模型，而不是绞尽脑汁地考虑如何将其多线程化。一旦开发人员建立好了模型，稍做修改总是能够方便地映射到Java提供的多线程编程模型上。

3、线程优先级

我们不能通过优先级指定谁先执行和后执行，因为我们在设置优先级是通过java实现的，而处理器和机器是不管这些的，其实也反应了java对处理器没有那么高的权限

如何控制优先级，主要是通过分配的时间片，

优先级高的线程分配时间片的数量要多于优先级低的线程。设置线程优先级时，针对频繁阻塞(休眠或者I/O操作)的线程需要设置较高优先级，而偏重计算(需要较多CPU时间或者偏运算)的线程则设置较低的优先级，确保处理器不会被独占。

4、线程状态

一共七个状态

通过下面代码表示wait time_wait block

package com.company.并发编程.day012_2021_02_25_THREAD;

import com.company.dem.WaitDemo;

import java.util.concurrent.TimeUnit;

/**
 * @Author rookie.li
 * @create 2021/2/25
 */
public class ThreadStateDemo {
    public static void main(String[] args) {
        new Thread(new TimeWaitDemo(), "TimeWaitingThread").start();
        new Thread(new waitDemo(), "WaitingThread").start();
        // 使用两个Blocked线程，一个获取锁成功，另一个被阻塞
        new Thread(new Blocked(), "BlockedThread-1").start();
        new Thread(new Blocked(), "BlockedThread-2").start();

    }
    static class  waitDemo implements Runnable{

        @Override
        public void run() {
            synchronized (WaitDemo.class){

                try {
                    WaitDemo.class.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    static  class  TimeWaitDemo implements Runnable{

        @Override
        public void run() {
            while (true){
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    static class  Blocked implements Runnable{

        @Override
        public void run() {
            synchronized (Blocked.class){
                while (true){
                    try {
                        TimeUnit.MILLISECONDS.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

线程个状态转换图

如上图，在线程调用start（）时进入就绪状态，调用wait（）方法时进入等待状态，进入等待状态的线程需要其他线程去notify（）唤醒，time wait的话就相当于，在wait的状态上添加了时间，当超过这个时间返回运行状态，当线程调用同步方法时，但是没有获取到对应的锁这个时候就会进入block状态。

Java将操作系统中的运行和就绪两个状态合并称为运行状态。阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态，但是阻塞在 java.concurrent包中Lock接口的线程状态却是等待状态，因为java.concurrent包中Lock接口对于阻塞的实现均使用了LockSupport类中的相关方法。

5、守护线程Daemon线程

Daemon线程属于支持线程

Daemon的作用是为其它线程的运行提供便利服务，守护线程最典型的应用就是GC（垃圾回收器）

public class DeamonDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new DeamonThread(), "de");
        //thread.setDaemon(true);
        thread.start();
        TimeUnit.MILLISECONDS.sleep(2000);
        System.out.println("main线程执行完成");

    }

    static class DeamonThread implements Runnable {

        @Override
        public void run() {
            int i = 0;
            while (true) {
                System.out.println("i = " + i);
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                i++;
            }
        }
    }
}