栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

线程(基础)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

线程(基础)

什么是程序:

是为了完成某个特定的任务,用某种语言编写的一组指令的集合。

简单来说:就是我们写的代码

程序进程线程: 进程:

(1)是指运行中的程序

比如说我们启动了一个英雄联盟,操作系统会自动为该进程分配一个内存空间,再启动一个穿越火线,操作系统又会为该进程分配一个新的内存空间。

(2)进程是程序的一次执行过程,或者是正在运行中的一个程序。是动态过程:它自身有产生、存在、消亡的过程。

线程:

1.是由进程创建的,是进程的一个实体

2.一个进程可以有多个线程

3.线程也可以创建线程

4.单线程:

同一时刻之允许执行一个线程

5.多线程:

同一时刻可以运行多个线程。 如:在qq这个进程里面打开多个聊天窗口......

并发并行:

并发:

同一时刻多个任务交替执行。 因为cup的切换任务速度快,所以给人的一种“貌似同时”错觉,单核心cpu实现的多任务就是并发。

并行:

同一时刻,多个任务同时执行,多核cup可以实现并行。

当进程过多,cup处理不过来,也会出现并发和并行同时存在。 

如何查看当前电脑可并行进程数量:

查看方法有很多种

这里用代码来查看展示:

public class SelectCpuMuch {
    public static void main(String[] args) {

        Runtime runtime = Runtime.getRuntime();

        //获取当前电脑cpu线程数量
        int num = runtime.availableProcessors();

        System.out.println("cup可同时运行进程数量:"+num);

    }
}

示例:

 如何创建线程 在Java中有两种方式创建线程:

1.继承Thread类,重写run()方法

2.实现Runnable接口,重写run()方法

类图:

 

 案例一:

编写一个程序,开启一个线程,该线程每隔一秒在控制台输出“我是猪猪侠”,当输出10条时结束程序。

先编写一个Test类继承Thread这个类:

class Test extends Thread {
    int num = 0;
    @Override

//重写run()方法

    public void run() {
        while (true) {
            System.out.println("我是猪猪侠" + (++num));
            try {
                Thread.sleep(1000);         //线程休眠一秒,即停止一秒再接着运行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (num == 10) {
                break;
            }
        }
    }
}

示例:

 执行过程:

 当程序启动时就会创建一个main线程,然后继续创建子线程,并且main线程不会被堵塞,main线程在执行,子线程也在执行,当main线程执行完成,子线程还可以继续执行,并不会因为main线程的完成而结束整个进程。子线程也可以创建线程。

main线程得实现线程接口

public static void main(String[] args) throws InterruptedException {

}

代码:

public class Thread_01 {
    public static void main(String[] args) throws InterruptedException {

        Test c = new Test();
        c.start();
        System.out.println("主线程继续运行");
        for(int i = 0;i < 5;i++){
            System.out.println("主线程 i="+i);
            Thread.sleep(1000);
        }
    }
}

class Test extends Thread {
    int num = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("我是猪猪侠" + (++num));
            try {
                Thread.sleep(1000);         //线程休眠一秒,即停止一秒再接着运行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (num == 10) {
                break;
            }
        }
    }
}

示例:

如果想要看到线程名可以用这个方法

Thread.currentThread().getName()
如何监视线程:

1.在终端输入这个指令

jconsole

进入这个界面,选择本地连接,选择这个类

 为什么不是调用run()方法,而是调用start()方法

1.因为run()方法只是一个普通的方法,如果调用的run()方法,程序会把run()方法先执行完,而此时执行这个线程的是main线程,这个可以通过查看线程名可以看的到,只有一个线程在执行,只有把run()方法执行完了才会执行main方法(),会阻塞在main()方法,没有真正启动线程,所以并不是多线程了。

2.代码示例

public class Thread_01 {
    public static void main(String[] args) throws InterruptedException {

        Test c = new Test();
        c.start();
        System.out.println("主线程继续运行");
        for(int i = 0;i < 5;i++){
            System.out.println("主线程 i="+i);
            Thread.sleep(1000);
        }
    }
}
class Test extends Thread {
    int num = 0;
    @Override
    public void run() {
        while (true) {
         System.out.println("我是猪猪侠" (++num)+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);         //线程休眠一秒,即停止一秒再接着运行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (num == 200) {
                break;
            }
        }
    }
}

示例:

 流程图:

使用Runnable接口实现多线程:

1.因为java继承机制是单继承,如果一个A类继承了一个B类再去继承Thread这个类显然是不行的所以java设计者提供了另一个方式实现多线程,那就是实现Runnable接口来实现多线程。

2.示例代码

public class Thread_02 {
    public static void main(String[] args) {
        Test02 test02 = new Test02();
        Thread thread = new Thread(test02);
        thread.start();

    }
}
class Test02 implements Runnable{
    int num = 0;
    @Override
    public void run() {
        while (true) {
          System.out.println("我是猪猪侠(++num)+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);         //线程休眠一秒,即停止一秒再接着运行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (num == 5) {
                break;
            }
        }
    }
}

 3.注意事项:

(1).Runnable接口是没有start()方法的,只有run()方法,但是上面说到,run()只是一个普通方法,不能真正实现多线程。

(2).创建一个Thread,把这个test02放进去,就可以使用sratr()方法了

4.示例

线程终止:

只需要将进入循环条件设置为私有,然后在主线程里设置成false,就有终止线程

代码示例:

public class Thread_04 {
    public static void main(String[] args) throws InterruptedException {

        Test test = new Test();
        test.start();

        Thread.sleep(5000);  //让主线程休眠5秒再启动,这时就会终止子线程

        test.setBool(false);

    }
}
class Test extends Thread{

   private boolean bool = true;

    @Override
    public void run() {
      while (bool) {
      System.out.println(Thread.currentThread().getName() + "线程运行中");
          try {
              Thread.sleep(50);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
    }
    public void setBool(boolean bool) {
        this.bool = bool;
    }
}

示例:

 线程提前终止休眠

线程提前终止休眠可以用interrupt()这个方法

代码示例:

public class Thread_05 {
    public static void main(String[] args) {

        Test_01 test_01 = new Test_01();
        test_01.setName("猪猪侠");
        

        test_01.start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("猪猪侠不想休眠了,继续吃");

        test_01.interrupt();//提前终止休眠,让线程继续执行
        
    }
}
class Test_01 extends Thread{
private boolean bool = true;
    @Override
    public void run() {
        while (true) {
                System.out.println(Thread.currentThread().getName() + "吃包子" );
            try {
                System.out.println(Thread.currentThread().getName() + "休眠中");
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + "提前中断休眠");
            }
        }
    }
}

示例:

线程设置优先级:

设置线程优先级为最低(等级1):

setPriority(Thread.MIN_PRIORITY)

设置线程优先级为最高(等级10):

setPriority(Thread.MAX_PRIORITY)

设置线程优先级为普通(等级5):

setPriority(Thread.NORM_PRIORITY

示例:

 

 用getPriority()这个方法可以获取到优先级

线程插队:

join()方法实现线程插队

线程插队一旦成功,肯定先执行完成插队线程的所有任务。

1.当不使用线程插队示例代码:

public class Thread_06 {
    public static void main(String[] args) throws InterruptedException {

        Test_03 test_03 = new Test_03();
        test_03.start();
        
        for(int i = 0;i < 10;i++){
            System.out.println("GG-bone");
        }
    }
}

class Test_03 extends Thread{
    int num = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("猪猪侠吃棒棒糖"+(++num));

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(num == 5){
                break;
            }
        }
    }
}

结果:

 可以看到先执行主线程,再执行子线程

2.当使用线程插队时

代码示例:

public class Thread_06 {
    public static void main(String[] args) throws InterruptedException {

        Test_03 test_03 = new Test_03();
        test_03.start();

        test_03.join(); //线程插队

        for(int i = 0;i < 10;i++){
            System.out.println("GG-bone");
        }
    }
}

class Test_03 extends Thread{
    int num = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("猪猪侠吃棒棒糖"+(++num));

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(num == 5){
                break;
            }
        }
    }
}

结果:

使用线程插队后,先执行完成插队线程再回去执行主线程 

 

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/959053.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号