【韩顺平】Java线程（基础）知识点总结

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建Cat对象,可以当作线程使用
        Cat cat = new Cat();
        cat.start();//启动线程->最终执行cat的run方法
        //说明：当main线程启动一个子线程Thread-0,主线程不会阻塞，会继续执行后面代码
        System.out.println("主线程继续执行 "+Thread.currentThread().getName());
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程 i="+i);
            //让主线程休眠1秒
            Thread.sleep(1000);
        }
    }
}

class Cat extends Thread{//当一个类继承了Thread类，该类就可以当作线程使用
    @Override
    public void run() {//重写run方法，实现自己的业务逻辑
        int times=0;
        while(true){
            //该线程每隔1秒，在控制台输出"猫咪学习java中"
            System.out.println("猫咪学习Java中"+"线程名"+(++times)+Thread.currentThread().getName());
            try {
                //使该线程休眠1秒
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times==8){
                break;//当times到8次时，线程退出
            }
        }
    }
}

为帮助大家更好的了解这段代码中线程创建的流程，下面讲解多线程的机制

3.1.1多线程的机制

以该代码为例

当我们运行程序时，就相当于启动了一个进程，然后，程序马上会进入我们的main方法中，进入main方法后，这时进程就开启了一个主线程叫做main线程。在这个主线程中，我们创建了一个Cat对象，由于这个Cat对象继承了Thread类，所以我们可以将其当作线程使用，因此当我们调用cat.start();时，我们的主线程就也创建了一个子线程叫做Thread-0线程，并且不会导致主线程阻塞（即主线程不会等到cat.start();方法执行完毕后，才继续执行后面代码）

如果我们运行程序，就会看到主线程和Thread-0线程交替执行，直到某一个线程先消亡，系统才会只执行那个未消亡的线程（但此时应用程序（进程）并未结束，只有所有线程都消亡了，我们的应用程序（进程）才会结束）

3.1.2为什么启动线程用的是cat.start();而不是直接用cat.run();

因为run方法只是一个普通方法，他并没有开启一个新的线程，因此如果我们在主线程中直接调用run方法，则自始至终都只有主线程在运行，导致主线程会发生阻塞（即系统会执行完run方法中的所有内容后再开始执行主线程中的后续代码）

下面通过源码解读cat.start()方法是如何启动线程的:

1.当我们调用cat.start();时，系统会进入public synchronized void start() {} 这个方法

public synchronized void start() {
        group.add(this);
        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

2.接着public synchronized void start() {} 这个方法会调用其中的核心方法start0();

start0()是一个本地方法，由JVM调用，底层由c/c++实现

真正实现多线程效果的是start0()方法,而不是run()方法

3.最后再在start0()方法中调用run()方法

private native void start0();
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

3.2实现Runnable接口，重写run方法

由于Java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类来创建线程是不可能的了，因此Java设计者们提供了实现Runnable接口的方法来创建线程

下面继续通过一个案例演示这种线程创建方法

提出需求：

请编写程序，该程序可以每隔1秒，在控制台输出"hi"，当输出10次后，自动退出

代码如下：

public class Thread02 {
    public static void main(String[] args) {
        Dog dog=new Dog();
        //dog.start();这里不能使用start
        //创建Thread对象，把dog对象（实现Runnable接口）,放入Thread
        Thread thread=new Thread(dog);
        thread.start();
    }
}
class Dog implements Runnable{//通过实现Runnable接口，开启线程
    int count=0;

    @Override
    public void run() {
        while (true){
            System.out.println("hi"+(++count)+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count==10){
                break;
            }
        }
    }
}

注意：

1.用实现Runnable接口的方法来创建线程时，创建对象后，不能用对象名.start()的方式开启线程，因为Runnable接口中没有start()方法而只有一个run()方法可以调用，虽然如此，我们仍然不能直接用对象名.run()的方式来开启线程，原因在3.1.2中已经分析过

2.解决办法：创建Thread对象，把我们需要当作线程的对象（实现Runnable接口）放入Thread中

然后再通过调用Thread对象中的start()方法完成线程的创建

小小西瓜呀

关注

8
点赞
踩
10

收藏

觉得还不错? 一键收藏
打赏
6
评论
【韩顺平】Java线程（基础）知识点总结

此篇文章总结自韩顺平老师所讲解的Java线程内容，我将会在引用韩老师原文的基础上增加自己的一些解读，以加深各位小伙伴对于Java线程的理解。希望能为各位学习Java的小伙伴带来帮助。
复制链接

扫一扫