Java多线程2 线程创建的两种方式与Thread类常用方法

关注

原创最新推荐文章于 2026-05-27 13:50:32 发布 346 阅读 AI 写同款· GEO 优化 ›

Java多线程--创建多线程的基本方式一：继承Thread类阅读详情

/*
线程的创建方式

一 Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现。
Thread类的特性
1，每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常
把run()方法的主体称为线程体
2，通过该Thread对象的start()方法来启动这个线程，而非直接调用run()
3，构造器
*Thread()：创建新的Thread对象
*Thread(String threadname)：创建线程并指定线程实例名
*Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
*Thread(Runnable target, String name)：创建新的Thread对象
4,常用方法
*void start(): 启动线程，并执行对象的run()方法
*void run(): 线程在被调度时执行的操作
*String getName(): 返回线程的名称
*void setName(String name):设置该线程名称，也可以通过构造器命名
*static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
*static void yield()：线程让步,主动释放当前线程的cpu资源，但下一步cpu如何分配无法确定。
1暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
2若队列中没有同优先级的线程，忽略此方法
*join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将
被阻塞，直到 join() 方法加入的 join 线程执行完为止，低优先级的线程也可以获得执行
*static void sleep(long millis)：(指定时间:毫秒)
1令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
2抛出InterruptedException异常
*stop(): 强制线程生命期结束，不推荐使用
*boolean isAlive()：返回boolean，判断线程是否还活着
使用注意：

如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
想要启动多线程，必须调用start方法。
一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。
5，yield()方法下一步执行哪个线程看概率，sleep()方法会使线程在之后确定的时间段内被阻塞，之后重新排队
join()方法会使当前线程被阻塞到插入的线程执行完毕后才会被执行。
6.join()方法与sleep()方法都需要处理异常。
7,Thread的匿名子类无法调用join方法，因为需要先调用一次start()方法启动线程才能加入其他线程中。

二 Java中线程的调度方法
1同优先级线程组成先进先出队列（先到先服务），使用时间片策略
2对高优先级，使用优先调度的抢占式策略

线程的优先级等级
thread类中的常量，可以直接调用
MAX_PRIORITY：10 最大
MIN _PRIORITY：1 最小
NORM_PRIORITY：5 默认

涉及的方法
getPriority() ：返回线程优先值
setPriority(int newPriority) ：改变线程的优先级，范围1-10

说明
线程创建时继承父线程的优先级,未设置情况下默认优先级是5.
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

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

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

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

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

package leanthread;

import com.sun.jmx.snmp.SnmpUnknownAccContrModelException;

import javax.xml.namespace.QName;

/**
 * @Description：
 * @Version：1.0.0.1
 * @Date：2020--03--03--22:07
 * @Author：wisdomcodeinside
 * @E-mail:liwenfeixiaoyao@163.com
 */
public class ThreadTest2 {
    public static void main(String[] args) {
        OddThread o = new OddThread();//主线程创建对象
        o.start();//start()方法开始创建分支线程，然后调用当前线程的run()方法，方法体是重写的方法体
//      o.run();//此时只是在主线程中执行对象的run()方法，不是在分支线程中运行。
//      o.start();//会报IllegalThreadStateException异常，同一个线程子类的对象不能启动两次。
        OddThread o1 = new OddThread("无名");
        o1.start();//新对象可以启动新线程
        Thread.currentThread().setName("老大哥");//可以对主线程命名
        Thread.currentThread().setPriority(10);//可以设置主线程优先级
        //主线程输出方法
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "主线任务"
                    + "任务等级" + Thread.currentThread().getPriority() + "完成次数" + i);//主线程与分支线程的输出会交错显示。
            if (i == 49) {
                try {
//                    new Thread(){
//                        @Override
//                        public void run() {
//                            for (int j = 0; j < 10; j++) {
//                                System.out.println("奇遇任务" + j);
//                            }
//                        }
//                    }//匿名子类无法start()
                    o1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        //对于只使用一次的线程可以使用匿名子类的方式
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + "\t无心");
                    if (i % 2 == 0) {
                        this.yield();
                        try {
                            sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + "\t法师");
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        //倒计时
        new Thread() {
            @Override
            public void run() {
                System.out.println("您的GTX690即将启动");
                for (int i =10; i > 0; i--) {
                    System.out.println(i);
                    try {
                        sleep(1000);//1000毫秒为1秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("Fallout");
            }
        }.start();
        //查看线程状态
        System.out.println(o.isAlive());
        System.out.println(o1.isAlive());
        System.out.println(Thread.currentThread().isAlive());
        //测试买票线程
        SellTicketWindow window1 = new SellTicketWindow("窗口1");
        SellTicketWindow window2 = new SellTicketWindow("窗口2");
        SellTicketWindow window3 = new SellTicketWindow("窗口3");
        window1.start();
        window2.start();
        window3.start();
        //测试买票线程
        TicketWindow t = new TicketWindow();
        Thread ticketWindow1 = new Thread(t);
        Thread ticketWindow2 = new Thread(t);
        Thread ticketWindow3 = new Thread(t);
        ticketWindow1.setName("卖票窗口1");
        ticketWindow1.start();
        ticketWindow2.setName("卖票窗口2");
        ticketWindow2.start();
        ticketWindow3.setName("卖票窗口3");
        ticketWindow3.start();
    }
}

class OddThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + "支线任务"
                        + "任务等级" + Thread.currentThread().getPriority() + "完成次数" + i);//获取当前线程的名字
            }
        }
    }

    public OddThread(String name) {
        super(name);
    }

    public OddThread() {
        super();
    }
}
//继承Thread类来创建线程
class SellTicketWindow extends Thread{
    private static int ticket = 100;//ticket是线程共用的属性，必须声明为static的，或者类继承Runnable接口
    private int total = 0;
    @Override
    public void run() {
        while (true) {
            if(ticket > 0){
                System.out.println(getName() + "卖出一张票，" + "票号为：" + ticket);
                ticket--;
                total++;
            }else{
                System.out.println("票已卖完，谢谢关照");
                System.out.println(Thread.currentThread().getName() + "总共卖出" + total + "张票");
                break;
            }
        }
    }
    public SellTicketWindow(String name){
        super(name);
    }
}
//实现Runnable接口来创建线程
class TicketWindow implements Runnable {
    private int ticket = 100;//线程共用一个对象，不用加上static
    @Override
    public void run() {
        while (true) {
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + "卖出一张票，" + "票号为：" + ticket);
                ticket--;
            }else{
                System.out.println("票已卖完，谢谢关照");
                break;
            }
        }
    }
}