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

本文介绍了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("主线程执行完毕");
    }

5、死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。

对于sleep()方法,我们首先要知道该方法是属于Thread类中的。而wait()方法,则是属于Object类中的。

sleep()方法导致了程序暂停执行指定的时间,让出cpu该其他线程,但是他的监控状态依然保持者,当指定的时间到了又会自动恢复运行状态。

在调用sleep()方法的过程中,线程不会释放对象锁。

而当调用wait()方法的时候,线程会放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象调用notify()方法后本线程才进入对象锁定池准备

获取对象锁进入运行状态。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值