自学内容网 自学内容网

Java多线程-----Thread类的基本用法,线程的状态及其转化 ✧*(ˊᗜˋ*) ✧*

😖一.开启一个线程start():

run()和start()的区别:

start():用 start方法来启动线程,是真正实现了多线程, 通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运行)状态,并没有运行,一旦得到cpu时间片,就开始执行run()方法。但要注意的是,此时无需等待run()方法执行完毕,即可继续执行下面的代码。所以run()方法并没有实现多线程。

run():run()方法只是类的一个普通方法而已,如果直接调用Run方法,程序中依然只有主线程这一个线程,其程序执行路径还是只有一条,还是要顺序执行,还是要等待run方法体执行完毕后才可继续执行下面的代码。

①.通过start()启动线程:

class MyThread2 extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println("what can I say");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        MyThread2 t = new MyThread2();
        //启动t线程
        t.start();
        //线程之间并发执行,主线程继续往下执行代码
        while(true){
            System.out.println("Mamba Out");
            Thread.sleep(1000);
        }
    }
}

运行结果(start是真正启动一个线程,所以两个线程并发执行):

②.通过类来调用run()方法:

class MyThread2 extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println("what can I say");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        MyThread2 t = new MyThread2();
        //通过类的实例来调用run()方法
        t.run();
        //线程之间并发执行,主线程继续往下执行代码
        while(true){
            System.out.println("Mamba Out");
            Thread.sleep(1000);
        }
    }
}

运行结果(可以看到这其实就是调用一个普通的方法):

run() 和 start()的区别理解二:

1、线程中的start()方法和run()方法的主要区别在于,当程序调用start()方法,将会创建一个新线程去执行run()方法中的代码但是如果直接调用run()方法的话,会直接在当前线程中执行run()中的代码,注意,这里不会创建新线程。这样run()就像一个普通方法一样。

2、另外当一个线程启动之后,不能重复调用start(),否则会报IllegalStateException异常。但是可以重复调用run()方法。

总结起来就是run()就是一个普通的方法,而start()会创建一个新线程去执行run()的代码

总结来说就是:

1、start方法用来启动相应的线程;

2、run方法只是thread的一个普通方法,在主线程里执行;

3、需要并行处理的代码放在run方法中,start方法启动线程后自动调用run方法;

4、run方法必须是public的访问权限,返回类型为void。

如果直接调用线程类的run()方法,这会被当做一个普通的函数调用,程序中仍然只有主线程这一个线程,也就是说,start()方法能够异步地调用run()方法,但是直接调用run()方法却是同步的,因此也就无法达到多线程的目的。

只有通过调用线程类的start()方法才能真正达到多线程的目的。

通过作用功能和运行结果的角度分析:

作用功能不同:

  • a.run 方法的作用时描述线程具体要执行的任务

  • b.start 方法的作用是真正去申请一个系统线程

运行结果不同:

  • a.run 方法是一个类的普通方法,主动调用和调用普通方法一样,会顺序执行一次;

  • b.start 方法调用执行后,start方法内部会调用Java本地方法(封装了对系统底层的调用)真正的启动一个线程,并执行run方法中的代码,run 方法执行完成后线程进入销毁阶段

start方法的执行一般是比较快的(创建线程,比较轻量),一旦start执行完毕后,新线程就会开始执行,调用start的线程,也会继续执行(main)。同时,调用start方法,不一定非得是main线程,任何的线程都可以创建其他线程。如果资源充裕,就可以任意的创建线程(线程也不是越多越好,同时,值得注意的是,由于线程的创建是有开销的,当主线程中还有要执行的代码时,一般是主线程的代码先执行(这个创建线程的时间是很短的)一部分。

😋二.线程的终止:

1.使⽤⾃定义的变量来作为标志位:

public class demo1 {
    private static boolean isQuit = false;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
           while(!isQuit){
               System.out.println("hello thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
            System.out.println("t 线程结束");
        });
        t.start();

        Thread.sleep(2000);
        //修改isQuit 变量,就能够影响到t 线程的结束了
        System.out.println("main线程尝试终止t线程");
        isQuit = true;
    }
}

运行结果:

2.Thread.currentThread().isInterrupted() 代替⾃定义标志位

public class demo3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            //t.isInterrupted();
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                   //throw new RuntimeException(e);
                    System.out.println("执行到catch操作");
                }
            }
        });
        //开启线程
        t.start();

        Thread.sleep(3000);
        System.out.println("尝试终止线程");
        t.interrupt();
    }
}

运行结果:

小结一下就是:①.Interrupt方法能够设置标志位,也能够唤醒sleep等阻塞方法

                         ②.sleep被唤醒后,又能清空标志位

🧐三.线程的休眠(sleep):

这是我们⽐较熟悉⼀组⽅法,有⼀点要记得,因为线程的调度是不可控的,所以,这个⽅法只能保证 实际休眠时间是⼤于等于参数设置的休眠时间的。

常用方法:

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        System.out.println(System.currentTimeMillis());
        Thread.sleep(1000);
        System.out.println(System.currentTimeMillis());
    }
}

运行结果:

😀四.线程的等待join():

有时,我们需要等待⼀个线程完成它的⼯作后,才能进⾏⾃⼰的下⼀步⼯作

常用方法:

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            for(int i = 0;i < 3;i++){
                System.out.println("Hello World~~");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        //开启t线程并让主线程等待t线程结束
        t.start();
        t.join();

        for(int i = 0;i < 3;i++){
            System.out.println("I am main Thread");
        }
    }
}

运行结果:

谁调用,谁就是被等待的,在哪里中调用,就是再哪里等待。这里再主线程中调用t.join(),所以是主线程等待t线程结束,而t线程是被等待的。可以看到直到t线程执行完成后,主线程才结束


练习一:

  1. 给定一个很长的数组 (长度 1000w), 通过随机数的方式生成 1-100 之间的整数.
  2. 实现代码, 能够创建两个线程, 对这个数组的所有元素求和.
  3. 其中线程1 计算偶数下标元素的和, 线程2 计算奇数下标元素的和.
  4. 最终再汇总两个和, 进行相加
  5. 记录程序的执行时间.

代码详解:

import java.util.*;
public class Demo1 {
    public static long sum1 = 0L;
    public static long sum2 = 0L;
    public static void main(String[] args) throws IOException, InterruptedException {
        long startTime = System.currentTimeMillis();//记录运行的起始时间
        int[] nums = new int[10000000];
        Random random = new Random();
        for(int i = 0;i < nums.length;i++){
            nums[i] = (random.nextInt(100) + 1);//1 ~ 100
        }
        //创建线程
        Thread t1 = new Thread(()->{
            for(int i = 0;i < nums.length;i += 2){
                sum1 += nums[i];
            }
            System.out.println("线程t1,偶数下标的总和是:" + sum1);
        });

        Thread t2 = new Thread(()->{
            for(int i = 1;i < nums.length;i += 2){
                sum2 += nums[i];
            }
            System.out.println("线程t2,奇数下标的总和是:" + sum2);
        });
        //开启线程
        t1.start();
        t1.join();
        t2.start();
        t2.join();

        long endTime = System.currentTimeMillis();//记录运行的终止时间

        System.out.println("这1000w个随机数的和是: " + (sum1 + sum2));
        System.out.println("一共的运行时间是: " + (endTime - startTime));
    }
}

 运行结果:

练习二:

有20个线程,需要同时启动。

每个线程按0-19的序号打印,如第一个线程需要打印0

请设计代码,在main主线程中,等待所有子线程执行完后,再打印 ok

代码 详解:

public class Demo5 {
    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[20];
        for(int i=0; i<20; i++){
            final int n = i;
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {//内部类使用外部的变量,必须是final修饰
                    System.out.println(n);
                }
            });
        }
        for(Thread t : threads){
            t.start();
        }
        for(Thread t : threads){//同时执行20个线程,再等待所有线程执行完毕
            t.join();
        }
        System.out.println("OK");
    }

}

运行结果(结果1~19,这里只展示部分,线程并发执行,抢占到CPU的运行权时期不同,造成的随机打印的结果):

 

😚五.获取一个线程的实例:

常用方法:

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            //获取当前线程的实例
            Thread cur = Thread.currentThread();
            for(int i = 0;i < 3;i++){
                System.out.println(cur.getName()+" :Hello World~~");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.setName("线程一");
        //开启t线程并让主线程等待t线程结束
        t.start();

    }
}

运行结果:

😆程的六个状态:

  1. 初始(NEW):新创建了一个线程对象,但还没有调用start()方法。
  2. 运行(RUNNABLE):Java线程中将就绪(ready)和运行中(running)两种状态笼统的称为“运行”。 线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中,等待被线程调度选中,获取CPU的使用权,此时处于就绪状态(ready)。就绪状态的线程在获得CPU时间片后变为运行中状态(running)。
  3. 阻塞(BLOCKED):表示线程阻塞于锁。
  4. 等待(WAITING):进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。
  5. 超时等待(TIMED_WAITING):该状态不同于WAITING,它可以在指定的时间后自行返回。
  6. 终止(TERMINATED):表示该线程已经执行完毕。

线程状态之间的转化: 

结语: 写博客不仅仅是为了分享学习经历,同时这也有利于我巩固知识点,总结该知识点,由于作者水平有限,对文章有任何问题的还请指出,接受大家的批评,让我改进。同时也希望读者们不吝啬你们的点赞+收藏+关注,你们的鼓励是我创作的最大动力!


原文地址:https://blog.csdn.net/2302_79862386/article/details/140515959

免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!