JavaWeb笔记03：多线程的创建、构造方法和属性_web项目多个构造方法怎么设置-CSDN博客

本文链接：https://blog.csdn.net/glpghz/article/details/104671969

文章目录

- 多线程的使用

多线程的使用

t.start 将线程放到就绪队列中，当线程被分配到CPU资源时，才会运行起来。

t 线程被调度下来的5中情况：
1：被高优先级抢占
2：执行结束
3：等待IO
4：主动放弃
5：时间片耗尽了

注意：

多线程，可能提升执行的速度（每多一个线程（调度单位），将相当于增加了抢到CPU的机会）。线程太多时，再加也无意义了，因为等待调度的都是咱们的线程了。
多线程的创建也耗费时间，如果耗费时间大于节省的时间，则不必采用多线程。
有些场景，需要创建多线程来提升效率，比如IO时。

1 创建线程

创建一个线程对象
调用start方法，把线程放到就绪队列中

创建线程对象的两种方式：
1) Thread直接创建

class MyThread extends Thread{
	@Override
	public void run(){
	//需要执行的代码
	}
}
Thread t = new MyThread();

2) 通过实现Runnable接口

class MyRunnable implements Runnable{
	@Override
	public void run(){
	//需要执行的代码
	}
}
Runnable target = new MyRunnable();
Thread  t = new Thread(target);

Thread 代表的是线程对象
Runnable 相当于一个需要线程执行的任务清单对象，它需要将Runnable对象交给Thread。

Thread——Runnable

Thread t = new MyThread();
Runnable target = t;
Thread p= new Thread(t); 等价于
Thread p=new Thread(target);

Thread源码：
public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

注意：

Thread也实现了Runnable接口，因此Thread对象也可以看成一个Runnable对象。
t.join: 主线程放弃抢占CPU，即主线程进入warting状态，直到t线程结束。
b.join()会抛出IntrrupedException异常

匿名内部类直接创建线程对象：

Thread

Thread a = new Thread(){
	@Override
	public void run(){
	//需要执行的代码
	}
}

Runnable

Thread d = new Thread(new Runnable() {
    @Override
    public void run() {
        sum();
    }
});

这个可以变形，为lamda表达式，alt+enter

Thread d = new Thread(() -> sum());

参考博客：lambda表达式——简介

2 线程构造方法和属性

线程的构造方法：

Thread()：创建线程对象
Thread(Runnable target) ：使用Runnable 对象创建线程对象
Thread(String name) ：创建线程对象，并命名
Thread(Runnable target, String name) ：使用Runnable 对象创建线程对象，并命名
Thread(ThreadGroup group, Runnable target)：线程可以被用来分组管理，分好的组为线程组，了解即可

线程命名使用：

Thread t3 = new Thread("这是我的名字");
Thread t4 = new Thread(new MyRunnable(), "这是我的名字");

线程的属性

ID	getId()
名称	getName()
状态	getState()
优先级	getPriority()
是否后台线程	isDaemon()
是否存活	isAlive()
是否被中断	isInterrupted()

线程调试：
Thread t = Thread.currentThread(): 获取当前进程(被哪个线程执行到，就在代表哪个线程)

注意：

线程分为：后台线程、前台（非后台）线程，非后台线程结束时，标志着整个线程结束。
JVM启动时就有好多线程，包括后台线程如垃圾回收线程GC（专门负责垃圾回收）等。
join其实是通过isAlive()判断线程是否结束来进行等待。

3 用jconsole查看不同线程的状态：

线程监视： cmd > jconsole
where jconsole 获取jconsole的路径

public class Test {
    private static void print() {
        Thread current = Thread.currentThread();
        // 之所以全部带着 id，是希望能分辨出我的打印是哪个线程打的
        System.out.println(current.getId() + ":" + current.getName());
        System.out.println(current.getId() + ":" + current.getPriority());
        System.out.println(current.getId() + ":" + current.getState());
        System.out.println(current.getId() + ":" + current.isDaemon());
        System.out.println(current.getId() + ":" + current.isAlive());
        System.out.println(current.getId() + ":" + current.isInterrupted());
    }
    public static void main(String[] args) {

        Thread t = new Thread(() -> {
            print();    // 在子线程中打印
            try{
                Thread.sleep(100000000);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        },"我是子线程");
        
        t.start();
        print();        // 在主线程中打印
        
        try{
            Thread.sleep(100000000);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
    }
}

通过Thread.sleep(100000000)（毫秒）让主线程和子线程都处于Timed-Waitting状态，以方便用jconsole进行观察。

通过jconsole观察属性：
1.属性的解释
2.属性的值

1）找到当前进程Test:

2）可以看到main主线程和”我是子线程“子线程：

线程优先级设置：

public class Main {
    private static class A extends Thread {
        @Override
        public void run() {
            System.out.println(" A");
        }
    }
    private static class B extends Thread {
        @Override
        public void run() {
            System.out.println(" B");
        }
    }
    public static void main(String[] args) {
        A a = new A();
        a.start();
        B b = new B();
        //b.setPriority(Thread.MAX_PRIORITY); // 优先级只是个建议
        b.start();
        System.out.println(" main");
    }
}