java基础——多线程的两种实现方式

Posted 2021-03-18 zsbenn

第一种实现方式：继承Thread类，并实现run方法，这种情况下每个线程对象都有一个独立的run方法

package thread;
/*
@author zsben
@create 2020-01-03 9:52

多线程创建的第一种方法：继承于Thread类
    1.创建一个继承于Thread的类
    2.重写Thread类的run方法-->将此线程执行的操作声明在run中
    3.创建Thread子类对象
    4.通过此对象调用start方法：启动当前线程，调用当前线程的run方法
*/

//1.创建一个继承Thread类的子类
class MyThread extends Thread{
    //2.重写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 ThreadTest {
    public static void main(String[] args) {
        //3.创建MyThread对象
        MyThread myThread = new MyThread();

        //4.调用start方法
        myThread.start();

        //myThread.run();如果只调用run方法，则只执行run里的代码，不新建新线程
        //myThread.start();一个已经在run的线程无法再次start

        MyThread myThread1 = new MyThread();
        myThread1.start();

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

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

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

    }
}

第二种实现方法：实现Runnable接口，并通过实现类作为参数new Thread对象

package thread;
/*
创建多线程的方式二：实现Runnable接口
1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable中的抽象方法：run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start()

Thread源码里，有一个Runnable对象target，
当调用Thread(Runnable o)时，target就被赋值为o
此时调用run方法时，就会调用target(即o)的run方法
如果target==null，那么调用run方法时，调用的就是Thread自己的run方法，就是继承Thread类的情况了

比较两种线程创建方式：
    开发中优先选择实现Runnable接口方式
        1.实现的方式没有类的单继承局限性
        2.实现的方式更适合处理多线程有共享数据情况

线程生命周期：                                            sleep(time),join()
   sleep()时间到，join()结束 |--->--------阻塞------<---|  等待同步锁，wait()
        获得同步锁，notify() |                          |  suspend()已被废弃
            resume()已被废弃 |       获取cpu执行权       |
    新建----------------->就绪<---------------------->运行------------------->死亡
            start()             失去cpu执行权或yield()       run()执行完，stop(),
                                                            出现Error或异常且没处理

@author zsben
@create 2020-01-03 13:16
*/

//1.创建一个实现了Runnable接口的类
class MyRunnable 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 RunnableTest {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MyRunnable myRunnable = new MyRunnable();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(myRunnable);
        //5.通过Thread类的对象调用start()
        t1.start();

        //再启动一个线程，run方法还是那个myRunnable对象里的run方法
        Thread t2 = new Thread(myRunnable);
        t2.start();
    }
}