2.线程创建方式（3种）(详解版) - Matrix锅锅

公告

Java多线程实现方式主要有四种：继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。

其中前两种方式线程执行完后都没有返回值，后两种是带返回值的。

1、继承Thread类

创建线程的步骤：

1 定义一个类继承Thread。

2 重写run方法。

3 创建子类对象，就是创建线程对象。

4 调用线程的start方法开启线程，一个线程一旦开启就会执行run方法中的所有代码。

注意： run方法千万不能直接调用，直接调用run方法相当于调用了一个普通的方法而已，并没有开启一个新的线程。

我们为什么要继承Thread类，并调用其的start方法才能开启线程呢？

继承Thread类：因为Thread类用来描述线程，具备线程应该有功能。那为什么不直接创建Thread类的对象呢？这样做没有错，但是该start调用的是Thread类中的run方法，而这个run方法没有做什么事情，更重要的是这个run方法中并没有定义我们需要让线程执行的代码。

package cn.itcast.thread;

public class Demo1 extends Thread {
     
    @Override
    public void run() {
        //自定义线程的任务代码
        for(int i  = 0 ; i< 100 ; i++){
            System.out.println("自定义线程："+i);
        }        
    }
    

    //每个线程都有自己的任务代码.....
    public static void main(String[] args) {
        //创建线程对象
        Demo1 d = new Demo1();
        //开启线程
        d.start();
        
        for(int i  = 0 ; i< 100 ; i++){
            System.out.println("主线程："+i);
        }
    }
    
}

2、实现Runnable接口

创建线程的步骤：

1. 自定义一个类去实现Runnable接口。

2. 实现了Runnable接口的run方法，把自定义线程的任务定义在run方法上。

3. 创建Runnable实现类的对象。

4. 创建Thread对象，并且把Runnable实现类对象作为参数传递进去。

5. 调用thread对象的start方法开启线程。

package duoxiancheng;

import java.lang.Thread;

public class Demo1 implements Runnable {

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
        System.out.println("当前线程对象：" + Thread.currentThread()); // 当前线程对象是： Thread
        System.out.println("当前对象：" + this); // this对象： Demo3的对象
    }

    public static void main(String[] args) {
        //创建Runnable实现类的对象
        Demo1 d = new Demo1();
        //创建Thread对象，并且把Runnable实现类对象作为参数传递进去
        Thread t = new Thread(d,"狗娃");        
        //调用thead对象的start方法开启线程。
        t.start();        
        //主线程执行的。
        for(int i = 0 ; i< 100 ; i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }

    }

}

原理：创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。 
Thread类使用了target变量记录了Runnable实现类对象。
                          
              public void run() {  //run方法的代码是属于线程的任务代码
                if (target != null) {  
                    target.run();    // 调用了Runanble实现类对象的run方法。 就是相当于把Runnable实现类的run方法作为了线程的任务代码去执行了。
                }
             }

如下：

Runnable方法：

　　Thread构造方法：

实现Runnable的好处

第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。

3、实现Callable接口

Callable与Runnable的区别

Runnable执行方法是run(),Callable是call()
实现Runnable接口的任务线程无返回值；实现Callable接口的任务线程能返回执行结果
call方法可以抛出异常，run方法若有异常只能在内部消化

Runnable只有一个run()函数，用于将耗时操作写在其中，该函数没有返回值。然后使用某个线程去执行该runnable即可实现多线程，Thread类在调用start()函数后就是执行的是Runnable的run()函数。Runnable的声明如下 :

Callable与Runnable的功能大致相似，Callable中有一个call()函数，但是call()函数有返回值，而Runnable的run()函数不能将结果返回给客户程序。Callable的声明如下 :

可以看到，这是一个泛型接口，call()函数返回的类型就是客户程序传递进来的V类型。

l ExecutorService：线程池类

l <T> Future<T> submit(Callable<T> task)：获取线程池中的某一个线程对象，并执行线程中的call()方法

l Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

使用线程池中线程对象的步骤：

1.创建线程池对象

2.创建Callable接口子类对象

3.提交Callable接口子类对象

4.关闭线程池

package duoxiancheng;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo5 {
    public static void main(String[] args) {

        //创建线程池对象

        ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象

        //创建Callable对象

        MyCallable c = new MyCallable();

         

        //从线程池中获取线程对象,然后调用MyRunnable中的run()

        service.submit(c);

         

        //再获取个教练

        service.submit(c);

        service.submit(c);

        //注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中

         

        //关闭线程池

        //service.shutdown();

        }
}

package duoxiancheng;

import java.util.concurrent.Callable;

public class MyCallable implements Callable {

    @Override

    public Object call() throws Exception {

        System.out.println("我要一个教练:call");

        Thread.sleep(2000);

        System.out.println("教练来了： " + Thread.currentThread().getName());

        System.out.println("教我游泳,交完后,教练回到了游泳池");

        return null;

    }

}

补充：线程的匿名内部类使用

Thread /Runnable

package duoxiancheng;

public class Demo2 {

    public static void main(String[] args) {
        // l 方式1：创建线程对象时，直接重写Thread类中的run方法
        new Thread() {

            public void run() {

                for (int x = 0; x < 40; x++) {

                    System.out.println(Thread.currentThread().getName()

                            + "...X...." + x);

                }

            }

        }.start();

        // l 方式2：使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法

        Runnable r = new Runnable() {

            public void run() {

                for (int x = 0; x < 40; x++) {

                    System.out.println(Thread.currentThread().getName()

                            + "...Y...." + x);
                }

            }

        };

        new Thread(r).start();

    }

}

线程的生命周期状态图

线程常用的方法：

Thread(String name) 初始化线程的名字

setName(String name) 设置线程对象名

getName() 返回线程的名字

static sleep() 哪个线程执行了sleep的代码，那么该线程就会睡眠指定毫秒数。

currentThread() 返回当前执行该方法的线程对象引用。

getPriority() 返回当前线程对象的优先级，默认线程的优先级是5

setPriority(int newPriority) 设置线程的优先级，虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的实现（最大的优先级是10 ，最小的1 ，默认是5）。

注：优先级越高的线程也不一定先执行完，只不过拿到CPU的概率变大了些。

摘：https://blog.csdn.net/Liu_yunzhao/article/details/78504287?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.nonecase

posted on 2020-05-19 21:13 Matrix锅锅阅读(198) 评论(0) 编辑收藏举报

刷新页面返回顶部

MatrixRhythm

公告

1、继承Thread类

2、实现Runnable接口

实现Runnable的好处

补充：线程的匿名内部类使用