多线程Thread与Runnable 以及五种状态

最新推荐文章于 2023-03-21 17:55:59 发布

lyc6681

最新推荐文章于 2023-03-21 17:55:59 发布

阅读量1.5k

点赞数

分类专栏：数据库文章标签： Thread与Run 多线程线程继承

本文链接：https://blog.csdn.net/lyc6681/article/details/72870406

版权

数据库专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文介绍了Java中实现多线程的两种方式：继承Thread类和实现Runnable接口，详细讲解了Thread类的工作原理以及Runnable接口的优势。同时，概述了线程的五种状态：新建、就绪、运行、阻塞和死亡，并对比了sleep()和wait()方法的区别。在多线程编程中，理解这些概念和状态转换对有效管理线程至关重要。

摘要由CSDN通过智能技术生成

多线程Thread与Runnable 以及五种状态

在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。
这样程序可以正常完成交互式运行。那么为啥非要使用start();方法启动多线程呢？
在JDK的安装路径下，src.zip是全部的java源程序，通过此代码找到Thread中的start()方法的定义，可以发现此方法中使用了private native void start0();其中native关键字表示可以调用操作系统的底层函数，那么这样的技术成为JNI技术（java Native Interface）
Runnable接口
在实际开发中一个多线程的操作很少使用Thread类，而是通过Runnable接口完成。
但是在使用Runnable定义的子类中没有start()方法，只有Thread类中才有。此时观察Thread类，有一个构造方法：public Thread(Runnable targer)此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多线程。（start()可以协调系统的资源）：
两种实现方式的区别和联系：
在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下好处：
避免点继承的局限，一个类可以继承多个接口。
适合于资源的共享
Runnable接口和Thread之间的联系：
public class Thread extends Object implements Runnable
发现Thread类也是Runnable接口的子类。

1、新建状态（New）：新创建了一个线程对象。

private static void showThread() {
        //建立线程对象
        MyThread myThread = new MyThread();
        //开启线程
        myThread.start();
    }

2、就绪状态（Runnable/ready）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

private static void showRunnable() {
        //1,创建一个XXXRunnable对象
        MyRunnable myRunnable = new MyRunnable();
        //2,创建一个Thread对象,并将上面创建的XXXRunnable对象传入构造方法中
        //public Thread(Runnable target)构造方法
        //target是Runnable接口类型
        //可以接收实现了Runnable接口的任何一个类的对象
        //经常说成:它(指的就是Runnable接口)的实现类对象
        Thread t1 = new Thread(myRunnable);
        t1.start();
        System.out.println(Thread.currentThread().getName());
        System.out.println("主线程走完了");
    }

3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
runnable = ready 和 running的

private static void showCreateMethod() {
        //匿名内部类+匿名对象的方式
        //调用start()方法开启线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("我是第一个线程");
                }
            }
        }).start();
        new Thread() {
            @Override
            public void run() {
                super.run();
                while (true) {
                    System.out.println("---------");
                }
            }
        }.start();
        /**
         * 线程是抢占运行
         * 谁抢到了CPU的执行权,那么谁就运行
         */}

4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。需要notifyAll唤醒
yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。

public class PrinterDeadLock {
    private String s1 = "我是s1";
    private String s2 = "我是s2";
    public void p1() {
        synchronized (s1) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                //s1是锁对象,调用了s1锁对象的wait方法
                //wait方法,会释放锁对象
                //并且,使得线程进入阻塞状态
                s1.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("s1锁住了p1");
            synchronized (s2) {
                for (int i = 0; i < 10; i++) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("s2锁住了p1");
                }
            }
        }
    }
    public void p2() {
        synchronized (s2) {
            System.out.println("s2锁住了p2");
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (s1) {
                    System.out.println("s1锁住了p2");
                    //调用s1锁对象的
                    //notifyAll方法
                    //会唤醒被s1调用wait方法
                    // 进入阻塞状态的线程
                    s1.notifyAll();
                }
            }
        }
    }
}

（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
这里写图片描述

    /**
     * synchronized,表示同步的意思
     *方法A执行完毕,方法B才跟着执行
     * 同步可以理解成等待某一事件结束才能开始做下一件事情
     * 同步是阻塞的,就是你做了这件事情,没做完就做不了别的事情
     * 异步就是做了一件事情没做完,就可以去做别的事情了
     */
    private static void showSynchronized() {
        SynDemo synDemo = new SynDemo();
        Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 synDemo.del1();
             }
         });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synDemo.show();
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                synDemo.del2();
            }
        });
        Thread t4 = new Thread(new Runnable() {
            @Override
            public void run() {
                synDemo.show1();
            }
        });
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

 private static void showJoin() throws InterruptedException {
        /**
         * join方法
         * t1.join()
         * 等待t1执行完,其他线程再执行
         * t1.join(500)
         * 等待t1执行500毫秒后,其他线程再执行
         */
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(i);
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t1.start();
        t1.join(500);
        System.out.println("主线程执行完毕");
    }