java创建线程的三种方式 - 多线程（一）

左手的ㄟ右手 2023-10-07 15:49 17阅读 0赞

## java创建线程的三种方式 ##

### 一.继承Thread类创建线程类 ###

（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。  
（2）创建Thread子类的实例，即创建了线程对象。  
（3）调用线程对象的start()方法来启动该线程。

package com.zm.thread;
    /**
     * （1）定义Thread类的子类 继承Thread
     */
    public class CreateByThread extends Thread{
        
    
        /**
         * （1）重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。
         * 因此把run()方法称为执行体。
         */
        @Override
        public void run() {
        
            // Thread.currentThread()方法返回当前正在执行的线程对象。
            // GetName()方法返回调用该方法的线程的名字。
            System.out.println(Thread.currentThread().getName()+"在运行");
        }
    
        public static void main(String[] args) {
        
            //（2）创建Thread子类的实例，即创建了线程对象。
            CreateByThread thread1 = new CreateByThread();
            CreateByThread thread2 = new CreateByThread();
            CreateByThread thread3 = new CreateByThread();
            // （3）调用线程对象的start()方法来启动该线程。
            thread1.start();
            thread2.start();
            thread3.start();
        }
    
    }

### 二.通过Runnable接口创建线程类（推荐） ###

（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。  
（2）创建 Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。  
（3）调用线程对象的start()方法来启动该线程。

package com.zm.thread;
    
    /**
     * （1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
     */
    public class CreateByRunnable implements Runnable{
        
    
        @Override
        public void run() {
        
            System.out.println(Thread.currentThread().getName()+"在运行");
        }
    
        public static void main(String[] args) {
        
            // （2）创建 Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
            CreateByRunnable runnable = new CreateByRunnable();
            Thread thread1 = new Thread(runnable);
            Thread thread2 = new Thread(runnable);
            Thread thread3 = new Thread(runnable);
            // （3）调用线程对象的start()方法来启动该线程。
            thread1.start();
            thread2.start();
            thread3.start();
        }
    
    }

### 三.通过Callable和Future创建线程 ###

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。  
（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。FutureTask是一个包装器，它通过接受Callable来创建，它同时实现了Future和Runnable接口。  
（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。  
（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

package com.zm.thread;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    /**
     * （1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
     */
    public class CreateByCallable implements Callable {
        
    
        @Override
        public Object call() throws Exception {
        
            return Thread.currentThread().getName() + "在运行";
        }
        
        public static void main(String[] args) {
        
            /**
             * （2）
             * 创建Callable实现类的实例，使用FutureTask类来包装Callable对象，
             * 该FutureTask对象封装了该Callable对象的call()方法的返回值。
             */
            CreateByCallable callable = new CreateByCallable();
            FutureTask futureTask1 = new FutureTask<>(callable);
            FutureTask futureTask2 = new FutureTask<>(callable);
            FutureTask futureTask3 = new FutureTask<>(callable);
            // （3）使用FutureTask对象作为Thread对象的target创建并启动新线程。
            Thread thread1 = new Thread(futureTask1, "thread1");
            Thread thread2 = new Thread(futureTask2, "thread2");
            Thread thread3 = new Thread(futureTask3, "thread3");
            thread1.start();
            thread2.start();
            thread3.start();
            // （4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
            try {
        
                System.out.println("futureTask1:" + futureTask1.get());
                System.out.println("futureTask2:" + futureTask2.get());
                System.out.println("futureTask3:" + futureTask3.get());
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            } catch (ExecutionException e) {
        
                e.printStackTrace();
            }
        }
    }

## 创建线程的三种方式的对比 ##

### 使用继承Thread类的方式创建多线程时 ###

优势是：

编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。

劣势是：

单继承的局限性。线程类已经继承了Thread类，所以不能再继承其他父类。

### 采用实现Runnable、Callable接口的方式创建多线程时 ###

优势是：

(1) 避免了继承Thread类的单继承的局限性。线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。【类只能单继承,类继承了Thread类就不能继承其他的类，而实现了Runnable接口,还可以继承其他的类,实现其他的接口】

(2) 降低了线程对象和线程任务的耦合性，增强了程序的可扩展性。  
把设置线程任务和开启新线程进行了分离(实现解耦)  
创建Thread类对象,构造方法中传递Runnable接口的实现类对象，可以传递不同的实现类(可扩展性)

(3)多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，将线程单独进行对象的封装，形成清晰的模型 ，更符合面向对象思想

劣势是：