Java 创建多线程的三种方式

左手的ㄟ右手 2022-11-04 11:20 268阅读 0赞

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

## 1. 继承Thread类 ##

继承Thread类，覆写run方法。

> 使用setName()和getName()来设置和获取线程的名字。

/** * 以火车票为例 */
    public class BuyTicketThreadExtend extends Thread { 
    
        // 总票数，为了使多个实例抢的都是这10张票，所以用static修饰
        static int ticketNumber = 10;
    
        // 设置线程名字的方法
        public BuyTicketThreadExtend(String name) { 
            setName(name);
        }
    
        /** * 覆写run方法 */
        @Override
        public void run() { 
            for (int i = 0; i < 100; i++) { 
                if (ticketNumber > 0) { 
                    System.out.println("我在" + getName() + "买到了，座号为：\t" + ticketNumber--);
                }
            }
        }
        
    }

实例化线程并启动线程：

public class BuyTicketThreadExtendTest { 
        public static void main(String[] args) { 
            BuyTicketThreadExtendt1 = new BuyTicketThreadExtend("one");
            t1.start();
            BuyTicketThreadExtendt2 = new BuyTicketThreadExtend("two");
            t2.start();
        }
    }

结果：

我在one买到了，座号为：	10
    我在two买到了，座号为：	10
    我在two买到了，座号为：	9
    我在two买到了，座号为：	8
    我在two买到了，座号为：	7
    我在two买到了，座号为：	6
    我在two买到了，座号为：	5
    我在two买到了，座号为：	4
    我在two买到了，座号为：	3
    我在two买到了，座号为：	2
    我在two买到了，座号为：	1

## 2. 实现Runnable接口 ##

实现Runnable接口，覆写run方法：

/** * 实现了这个接口，才会变成一个线程类。 */
    public class BuyTicketThreadImplements implements Runnable { 
        // 火车票张数，我们没有加上static修饰符
        int ticketNumber = 10;
    
        @Override
        public void run() { 
            for (int i = 0; i < 100; i++) { 
                if (ticketNumber > 0) { 
                    System.out.println("我在" + Thread.currentThread().getName() + "买到了票，座号为" + ticketNumber--);
                }
            }
        }
    }

实例化线程类并将其作为参数传递给Thread构造方法：

public class BuyTicketThreadImplementsTest { 
        public static void main(String[] args) { 
            BuyTicketThreadImplements tti = new BuyTicketThreadImplements();
            Thread t1 = new Thread(tti, "窗口1");
            Thread t2 = new Thread(tti, "窗口2");
            t1.start();
            t2.start();
    
        }
    }

结果：

我在窗口1买到了票，座号为10
    我在窗口2买到了票，座号为9
    我在窗口2买到了票，座号为8
    我在窗口2买到了票，座号为7
    我在窗口2买到了票，座号为6
    我在窗口2买到了票，座号为4
    我在窗口2买到了票，座号为3
    我在窗口2买到了票，座号为2
    我在窗口2买到了票，座号为1
    我在窗口1买到了票，座号为5

> **思考：现在已经知道两种方式，到底哪一种方式更好呢？**
> 
>  *  在Java中是单继承的，所以我们继承了Thread类就没法继承其他的类，所以我们更多的使用的是实现Runnable接口。
>  *  实现了Runnable的方式共享资源的能力的更强，不需要加一个static来修饰。适合多个相同程序代码的线程去处理同一个资源的情况，把线程同程序代码、数据有效的分离，很好地体现了面向对象的设计思想。
> 
> 所以在大部分的应用程序中都会采用第二种方式来创建多线程，即实现Runnable接口。  
>   
> 
> 
> 我们通过类的继承关系也可以看到，Thread本质上也是去实现了Runnable接口：  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]

## 3. 实现了Callable接口 ##

> 上面的两种方法，我们都是通过覆写run方法来书写自己的代码，可是这样会有个问题，首先如果我们希望自己的方法可以返回一些值，这是无法做到的：  
> ![在这里插入图片描述][20210302134654542.png]  
> 其次我们想要在方法上抛出一些异常也是不可以的：  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 1]

基于上面两点，JDK1.5之后出现了第三种创建线程的方式，实现Callable接口，实现了Callable接口有两点好处：

*  可以有返回值
 *  能抛出异常

当然也有一些缺点，就是线程的创建有点麻烦。

> 我们看一下Callable的源代码：  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 2]  
> 我们看到Callable是泛型接口。
> 
> 如果我们在继承的时候写了类型，call方法的返回值就是指定类型的，而且可以抛出异常了：
> 
>     public class CreateNewThread3 implements Callable<Integer> { 
>         @Override
>         public Integer call() throws Exception { 
>             return null;
>         } 
>     }

我们创建一个实现了Callable接口的类：

/** * 返回一个10以内的随机数 */
    public class CreateNewThread3 implements Callable<Integer> { 
        @Override
        public Integer call() throws Exception { 
            return new Random().nextInt(10);
        }
    }

我们怎么样来实例化并启动类：

@Test
    public void testCreateNewThread3() throws ExecutionException, InterruptedException { 
        // 创建我们刚才写的类的实例
        CreateNewThread3 newThread3 = new CreateNewThread3();
        
        // 将该实例传递给FutureTask的构造方法，得到futureTask对象
        FutureTask futureTask = new FutureTask<>(newThread3);
        
        // 将futureTask实例传递给Thread的构造方法，得到Thread的对象
        Thread thread = new Thread(futureTask);
        
        // start实例
        thread.start();
        
        // 利用futureTask的get方法来获取返回值
        Object o = futureTask.get();
        
        System.out.println(o);
    }

我们可以看到非常的麻烦，需要借助一个中间类FutureTask。

这些类之间的关系：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][20210302154933104.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]: /images/20221023/fba36e6c34ae40d083ed8fdf52a7cc34.png
[20210302134654542.png]: /images/20221023/9d311ebe497b4e97af81cc0d9fe43dfe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 1]: /images/20221023/e6c2d1acdd6a4c85aa303b4adddfc393.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 2]: /images/20221023/5d45e81cdcd946d9ab20d58cd69e8678.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 3]: /images/20221023/de5941e3259a4c2f83dabcf7fde5f548.png
[20210302154933104.png]: /images/20221023/22d4f431616341e1b777b628380af814.png