Java多线程基本知识--概念、创建

旧城等待， 2024-03-30 11:05 147阅读 0赞

## 一、线程、进程、多线程 ##

1、进程

进程是执行程序的一次执行过程，是系统资源分配的单位。

2、线程

一个进程可以包含多个线程，一个进程至少有一个线程。线程是CPU调度和执行的单位。

## 二、线程的创建 ##

#### 1、Thread：继承Thread类，Thread类实现了Runable接口。 ####

方式：自定义线程类继承Thread 》重写run方法，编写线程执行体 》 创建线程对象调用start

public class MyThread extends Thread{
        @Override
        public void run(){
            for (int i = 0; i < 20; i++) {
                System.out.println("这是一个线程"+i);
            }
        }
    
        public static void main(String[] args) {
            //main主线程
            for (int i = 0; i < 20; i++) {
                System.out.println("这是一个线程"+i);
            }
    
            //副线程
            MyThread myThread=new MyThread();
    //        myThread.run();
            //开启线程 
            myThread.start();
    
        }
    
    }

![fc875b0074b640c2a58909e33fe827a8.png][]

#### 2、Runnable：实现Runnable接口。 ####

方式：自定义类实现Runnable 》重写run方法，编写线程执行体 》 创建线程对象调用start

public class RunnableTest implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                System.out.println("测试"+i);
            }
        }
    
        public static void main(String[] args) {
            RunnableTest runnableTest=new RunnableTest();
            Thread thread=new Thread(runnableTest);
            thread.start();
    
            for (int i = 0; i < 200; i++) {
                System.out.println("主线程在运行"+i);
            }
    
        }
    }

####  ####

#### 3、Callable：实现Callable接口。 ####

实现Callable接口，需要返回值类型。

重写call方法需要抛出异常。

public class CallabaleTest implements Callable<Boolean> {
        @Override
        public Boolean call() throws Exception {
            System.out.println("副线程执行");
            return true;
        }
    
        public static void main(String[] args) {
            CallabaleTest t1=new CallabaleTest();
            CallabaleTest t2=new CallabaleTest();
            CallabaleTest t3=new CallabaleTest();
    
            //创建执行服务
            ExecutorService service= Executors.newFixedThreadPool(3);
    
            //提交执行
            Future<Boolean> r1=service.submit(t1);
            Future<Boolean> r2=service.submit(t2);
            Future<Boolean> r3=service.submit(t3);
    
            //获取结果
            try {
                Boolean aBoolean = r1.get();
                Boolean bBoolean = r2.get();
                Boolean cBoolean = r3.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
    
            //关闭
            service.shutdown();
        }
    }

## 三、线程状态 ##

#### ![ebb16e56ed58460a83fe47e0ef4307fa.png][] ####

![2609f48f99e84656b41809379537ba47.png][]

![b37266a5ef0a4cfe95b58f69078ad476.png][]

#### 1、停止线程 ####

方式：建议线程正常停止、建议使用标志位、不要使用stop和destroy。

例子：使用标志位

public class ThreadStop implements Runnable{
        //标志位
        private Boolean flag=true;
    
        @Override
        public void run() {
            while (flag){
                System.out.println("running");
            }
        }
    
        //停止方法
        public void stop(){
            flag=false;
        }
    
        public static void main(String[] args) {
            //开启线程
            ThreadStop stop=new ThreadStop();
            new Thread(stop).start();
    
            for (int i = 0; i < 10000; i++) {
                if(i==900){
                    stop.stop();
                    break;
                }
            }
    
        }
    
    }

#### 2、线程休眠 ####

sleep指定当前线程阻塞的毫秒数；

sleep存在异常InterruptedException；

sleep时间达到后线程进入就绪状态；

sleep可以模拟网络延时，计时器等；

每个对象都有一个锁，sleep不会释放锁；

#### 3、线程礼让 ####

礼让线程，让当前正在执行的线程暂停，但不阻塞；

将线程从运行状态转为就绪状态；

让CPU重新调度，礼让不一定成功。

public class ThreadStop implements Runnable{
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"线程开始执行");
            Thread.yield();//线程礼让
            System.out.println(Thread.currentThread().getName()+"线程结束执行");
        }
    
        public static void main(String[] args) {
            //开启线程
            ThreadStop stop=new ThreadStop();
            new Thread(stop,"1").start();
            new Thread(stop,"2").start();
    
        }
    
    }

#### 4、线程强制执行(Join) ####

join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞。类似插队。

public class ThreadStop implements Runnable{
    
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println("副线程");
            }
        }
    
        public static void main(String[] args) {
            //开启线程
            ThreadStop stop=new ThreadStop();
            Thread thread = new Thread(stop, "1");
            thread.start();
    
            for (int i = 0; i < 100; i++) {
                System.out.println("主线程");
                if(i==20){
                    try {
                        //此时会让副线程执行完再执行主线程
                        thread.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    
    }

#### 5、线程状态观测 ####

Thread.State state=thread.getState()；

线程状态：

NEW：尚未启动的线程处于此状态

RUNNABLE：在JAVA虚拟机中执行的线程处于此状态

BLOCKED：被阻塞等待监视器锁定的线程处于此状态

WAITING：正在等待另一个线程执行特定动作的线程处于此状态

TIMED WAITING：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态

TERMINATED：已退出线程

#### 6、线程的优先级 ####

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度那个线程来执行。

线程的优先级用数字表示，范围1-10

Thread.MIN\_PROIRITY=1;

Thread.MAX\_PROIRITY=10;

Thread.NORM\_PROIRITY=5;

使用以下方式改变和获取优先级

getPriority() ; setPriority(int xxx);

注意：优先级低只是意味获得调度的概率低，并不是优先级低就不会被调用，都看CPU掉度。

public class ThreadStop implements Runnable{
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        }
    
        public static void main(String[] args) {
            System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
            //开启线程
            ThreadStop stop=new ThreadStop();
            Thread thread1 = new Thread(stop, "1");
            Thread thread2 = new Thread(stop, "2");
            Thread thread3 = new Thread(stop, "3");
            Thread thread4 = new Thread(stop, "4");
            Thread thread5 = new Thread(stop, "5");
    
            thread1.setPriority(1);
            thread2.setPriority(10);
            thread3.setPriority(Thread.MIN_PRIORITY);
            thread4.setPriority(Thread.MAX_PRIORITY);
    
            thread1.start();
            thread2.start();
            thread3.start();
            thread4.start();
            thread5.start();
        }
    
    }

#### 7、守护(daemon)线程 ####

线程分为用户线程和守护线程

虚拟机必须确保用户线程执行完毕

虚拟机不用等待守护线程执行完毕

作用后台操作日志、监控内存、垃圾回收

Thread thread=new Thread();
    //默认false表示用户线程
    thread.setDaemon(true);

[fc875b0074b640c2a58909e33fe827a8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/97a7c0bf00cb426ba571a45572da32a2.png
[ebb16e56ed58460a83fe47e0ef4307fa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/05fa1053ddb6402290314016bc8abb0c.png
[2609f48f99e84656b41809379537ba47.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1e10ade5c56c422fa85e9bb008752a0c.png
[b37266a5ef0a4cfe95b58f69078ad476.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/6315c59f2f8d40e08ce04108276bef7e.png