多线程02 线程的创建和使用（创建和启动，Tread类，API中创建线程的两种方式，继承方式和实现方式的联系与区别，线程的调度，线程的优先级，线程的分类）

九命猫小宇

已于 2022-01-18 20:00:01 修改

阅读量94

点赞数

文章标签：分类 java 数据挖掘

于 2022-01-18 19:51:30 首次发布

本文链接：https://blog.csdn.net/lxy13263050001/article/details/122567163

版权

线程的创建和使用

线程的创建和启动

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现
Thread类的特性
- 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
- 通过该Thread对象的==start()==方法来启动这个线程，而非直接调用run()

Thread类

构造器：
- Thread()：创建新的Thread对象
- Thread(String threadname)：创建线程并指定线程实例名
- Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
- Thread(Runnable target, String name)：创建新的Thread对象

API中创建线程的两种方式

JDK1.5之前创建新执行线程有两种方法：
- 继承Thread类的方式
- 实现Runnable接口的方式

方式一：继承Thread类

定义子类继承Thread类
子类中重写Thread类中的run方法
创建Thread子类对象，即创建了线程对象
调用线程对象start方法：启动线程，调用run方法

package com.atguigu.java;

/**
 * 例子：创建三个窗口卖票，总票数为100张，使用继承Thread类的方式
 *
 * 存在线程安全问题，待解决
 *
 * @Author damao
 * @Date 2022/1/18 9:07
 * @Version 1.0
 */
class Window extends Thread{
    private static int ticket = 100;

    public void run(){

        while (true){
            if (ticket>0){
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                ticket--;
            }else {
                break;
            }
        }

    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

package com.atguigu.java;

/**
 * 例子：创建三个窗口卖票，总票数为100张，使用继承Thread类的方式
 *
 * 存在线程安全问题，待解决
 *
 * @Author damao
 * @Date 2022/1/18 9:07
 * @Version 1.0
 */
class Window extends Thread{
    private static int ticket = 100;

    public void run(){

        while (true){
            if (ticket>0){
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                ticket--;
            }else {
                break;
            }
        }

    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xoY6V4wM-1642507122930)(C:\Users\asus\Desktop\image-20220117213941793.png)]$

注意点：
- 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式
- run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定
- 想要启动多线程，必须调用start方法
- 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”

package com.atguigu.java;

/**
 * 多线程的创建，方式一：继承于Thread类
 * 1.创建一个继承于Thread类的子类
 * 2.重写Thread类的run()方法 --> 将此线程执行的操作声明在run()中
 * 3.创建Thread类的子类的对象
 * 4.通过此对象调用start()
 *
 * 例子：遍历100以内的所有偶数
 *
 * @Author damao
 * @Date 2022/1/17 20:09
 * @Version 1.0
 */

//1.创建一个继承于Thread类的子类
class MyThread extends Thread {
    //2.重写Thread类的run()方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 ==0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class TreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类的对象
        MyThread t1 = new MyThread();

        //4.通过此对象调用start()：①启动当前线程②调用当前线程的run()
        t1.start();
        //问题一：我们不能通过直接调用run()的方式启动线程
//        t1.run();

        //问题二：再启动一个线程，遍历100以内的偶数,不可以还让已经start()的线程去执行。会报IllegalThreadStateException
//        t1.start();
        //我们需要重新创建一个线程的对象
        MyThread t2 = new MyThread();
        t2.start();


        //如下操作仍然是在main线程中执行
        for (int j = 0; j < 100; j++) {
            if (j % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + j);
            }
        }
        System.out.println("===========");
    }
}

方式二：实现Runnable接口

定义子类，实现Runnable接口
子类中重写Runnable接口中的run方法
通过Thread类含参构造器创建线程对象
将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中
调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法

package com.atguigu.java;

/**
 * 例子：创建三个窗口卖票，总票数为100张，使用实现Runnable接口的方式
 *存在线程安全问题，待解决
 *
 * @Author damao
 * @Date 2022/1/18 19:21
 * @Version 1.0
 */
class Window1 implements Runnable{

    private int ticket = 100;

    @Override
    public void run() {
        while(true){
            if (ticket > 0){
                System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

package com.atguigu.java;

/**
 * 创建多线程的方式二：实现Runnable接口
 * 1.创建一个实现了Runnable接口的类
 * 2.通过实现类实现Runnable中的方法：run()
 * 3.创建实现类的对象
 * 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5.通过Thread类的对象调用start()
 *
 * 比较创建线程的两种方式：
 * 开发中：优先选择：实现Runnable接口方式
 * 原因：1.实现的方式没有类的单继承性的局限性
 *       2.实现的方式更适合来处理多个线程有共享数据的情况
 *
 * 联系：public class Tread implements Runnable
 * 相同点：两种方式都需要重写run()，将线程执行的逻辑声明2在run()中
 *
 * @Author damao
 * @Date 2022/1/18 15:51
 * @Version 1.0
 */
//1.创建一个实现了Runnable接口的类
class MThread implements Runnable{
    //2.通过实现类实现Runnable中的方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }

        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MThread mThread = new MThread();
        //4.将此对象作为参数传递到Thread类的构造器
        Thread t1 = new Thread(mThread);
        t1.setName("线程1");
        //5.通过Thread类的对象调用start()：①启动线程②调用当前线程的run()-->调用了Runnable类型的target的run()
        t1.start();

        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }
}

继承方式和实现方式的联系与区别

public class Thread extends Object implements Runnable

区别：
- 继承Thread：线程代码存放Thread子类run方法中
- 实现Runnable：线程代码存在接口的子类的run方法
实现方式的好处：
- 避免了单继承的局限性
- 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源

练习

练习：创建两个分线程，其中一个线程遍历100以内的偶数，另一个线程遍历100以内的奇数

package com.atguigu.exer;

/**
 * 练习：创建两个分线程，其中一个线程遍历100以内的偶数，另一个线程遍历100以内的奇数
 *
 *
 * @Author damao
 * @Date 2022/1/17 20:50
 * @Version 1.0
 */
public class ThreadDemo {
    public static void main(String[] args) {
//        MyThread1 m1 = new MyThread1();
//        MyThread2 m2 = new MyThread2();
//
//        m1.start();
//        m2.start();

        //创建Thread类的匿名方式
        new Thread(){
            public void run(){
                for (int i = 0; i < 100; i++) {
                    if (i % 2 == 0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();

        new Thread(){
            public void run(){
                for (int i = 0; i < 100; i++) {
                    if (i % 2 != 0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();
    }
}

class MyThread1 extends Thread{
    public void run(){
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

class MyThread2 extends Thread{
    public void run(){
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

Thread类的有关方法

void start(): 启动线程，并执行对象的run()方法
run(): 线程在被调度时执行的操作
String getName(): 返回线程的名称
void setName(String name):设置该线程名称
static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
static void yield()：线程让步
- 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
- 若队列中没有同优先级的线程，忽略此方法
join() **：**当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
- 低优先级的线程也可以获得执行
static void sleep(long millis)：(指定时间:毫秒)
- 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队
- 抛出InterruptedException异常
stop(): 强制线程生命期结束，不推荐使用
**boolean isAlive()****：**返回boolean，判断线程是否还活着

package com.atguigu.java;

/**
 * 测试Thread类中的常用方法：
 * 1.start()：启动当前线程：调用当前线程的run()
 * 2.run()：通常需要重写Thread类中的此方法，将创建的线程执行的操作声明在此方法中
 * 3.currentThread()：静态方法，返回执行当前代码的线程
 * 4.getName()：获取当前线程的名字
 * 5.setName()：设置当前线程的名字
 * 6.yield()：释放当前CPU的执行
 * 7.join()：在线程A中调用线程B的join方法，此时线程A就进入阻塞状态，直到线程B完全执行完之后，线程A
 *           结束阻塞状态
 * 8.stop()：已过时。当执行此方法时，强制结束当前线程
 * 9.sleep(long millitime)：让当前线程“睡眠”指定的millitime毫秒，在指定的millitime毫秒时间内，当前
 *                        线程是阻塞状态
 *10.isAlive()：判断当前线程是否存活
 *
 *线程的优先级：
 * 1.
 * MAX_PRIORITY：10
 * MIN_PRIORITY：1
 * NORM_PRIORITY：5 --> 默认的优先级
 * 2.如何获取和设置当前线程的优先级
 * getPriority()：获取线程的优先级
 * setPriority(int p)：设置线程的优先级
 *
 * 说明：高优先级的线程要抢占低优先级线程CPU的执行权，但是只是从概率上讲，高优先级的线程高概率的情况下
 * 被执行。并不意味着只有当高优先级的线程执行完之后，低优先级的线程才执行
 *
 * @Author damao
 * @Date 2022/1/17 21:45
 * @Version 1.0
 */
class HelloThread extends Thread{
    public void run(){
        for (int i = 0; i < 100; i++) {
            if (i % 2 ==0){

//                try {
//                    sleep(10);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }

                System.out.println(Thread.currentThread().getName() + ":" +Thread.currentThread().getPriority() + ":" + i);
            }
//            if (i % 20 == 0){
//                //this是当前的对象
//                this.yield();
//            }
        }
    }

    //通过构造器的方式给线程命名
    public HelloThread(String name){
        super(name);
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) {

        HelloThread h1 = new HelloThread("Thread:1");

//        h1.setName("线程一");

        //设置分线程的优先级
        h1.setPriority(Thread.MAX_PRIORITY);

        h1.start();

        //给主线程命名
        Thread.currentThread().setName("主线程");
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
            }

//            if (i == 20) {
//                try {
//                    h1.join();
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }
        }

//        System.out.println(h1.isAlive());
    }
}

线程的调度

调度策略
- 时间片
  - $[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XWBAgtDL-1642507122931)(C:\Users\asus\Desktop\image-20220118194222995.png)]$
- 抢占式：高优先级的线程抢占CPU
Java的调度方法
- 同优先级线程组成先进先出队列（先到先服务），使用时间片策略
- 对高优先级，使用优先调度的抢占式策略

线程的优先级

线程的优先级等级
- MAX_PRIORITY：10
- MIN_PRIORITY：1
- NORM_PRIORITY：5
涉及的方法：
- getPriority() **：**返回线程优先值
- setPriority(int newPriority) **：**改变线程的优先级
说明
- 线程创建时继承父线程的优先级
- 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

补充：线程的分类

Java中的线程分为两类：一种是守护线程，一种是用户线程。

它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开
守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程
Java垃圾回收就是一个典型的守护线程
若JVM中都是守护线程，当前JVM将退出
形象理解：兔死狗烹，鸟尽弓藏

九命猫小宇

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫