启动多线程的三个方法

红太狼 2022-11-18 01:43 227阅读 0赞

**1、多线程**  
了解线程之前我们必须要先了解（程序—>进程—>线程）的过程

**程序**：是一组计算机能识别和执行的指令，运行于电子计算机上，满足人们某种需求的信息化工具。  
**进程**：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。  
**线程**：线程是进程中的一个执行单元，负责当前进程中程序的执行，**一个进程中至少有一个线程。一个进程中是可以有多个线程的**，这个应用程序也可以称之为多线程程序。  
总之一个程序至少有一个进程，一个进程至少有一个线程。

那么如果要想实现一个多线程的主类，有两类途径：  
集成一个Thread类  
实现Runnable、Callable接口。

**1、继承Tread类**  
1）、定义一个实现类继承于Thread类  
2）、重新run方法  
3）、启动程序new实现类，调用start()方法：当调用run方法时，run方法将会在主线中调用，依旧是单线程。

public class TestThread { 
        public static void main(String[] args) { 
            //new 定义的类
            MyThread myThread = new MyThread();
            //使用start()方法启动线程
            myThread.start();
    
            //main线程也启动
            for (int i = 0; i < 10; i++) { 
                System.out.println("我是main线程："+i);
            }
        }
    }
    
    //新建一个类继承Thread
    class MyThread extends Thread{ 
        //重写Thread类中的run方法
        @Override
        public void run() { 
            for (int i = 0; i < 10; i++) { 
                System.out.println("我是线程："+Thread.currentThread().getName()+":"+i);
            }
        }
    }

**2、实现Runnable接口**  
1）、创建当前类实现Runnadble接口  
2）、重新run方法  
3）、在主线程main中启动线程，这里启动时需要new Thread对象并将当前类放入Thread对象中，再启动Thread方法中的start()方法。  
注意：因为Thread也是实现Runnable，且Runnable是一个函数式接口满足lamdba表达式运行：new Thread(lamdba表达式).start();

public class TestThread02 { 
        public static void main(String[] args) { 
            //启动线程方法一
    // MyRunnableThread runnableThread = new MyRunnableThread();
    // new Thread(runnableThread).start();
    
            // 使用匿名内部类
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    for (int i = 0; i < 10; i++) { 
                        System.out.println("我是线程："+Thread.currentThread().getName()+":"+i);
                    }
                }
            }).start();
    
            // 使用lamdba表达式启动：因为Runnable是一个函数式接口（在匿名类不类中更加简化）
            new Thread(()->{ 
                for (int i = 0; i < 10; i++) { 
                    System.out.println("我是线程："+Thread.currentThread().getName()+":"+i);
                }
            }).start();
    
            //main线程也启动
            for (int i = 0; i < 10; i++) { 
                if(i>=5){ 
                    try { 
                        Thread.sleep(5);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
                System.out.println("我是main线程："+Thread.currentThread().getName());
            }
        }
    }
    
    //新建一个类实现Runnable接口
    class MyRunnableThread implements Runnable{ 
        //重新run方法
        @Override
        public void run() { 
            for (int i = 0; i < 10; i++) { 
                System.out.println("我是线程："+Thread.currentThread().getName()+":"+i);
            }
        }
    }

**3、实现Callable接口**  
1）、定义类实现Callable接口  
2）、重写call方法（call方法有返回值）  
3）、new 实现对象  
4）、new FutureTask 实现类 用于接收运算结果。（它们都是java.util.concurrent包下的类）  
5）、new Thread(FutureTask对象返回的数据).start(); 启动

import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    public class TestCallableThread { 
    
        public static void main(String[] args) { 
            //new 实现对象
            MyCallable myCallable = new MyCallable();
            //new FutureTask 实现类 用于接收运算结果。 FutureTask 是 Future 接口的实现类
            FutureTask<Boolean> task = new FutureTask<Boolean>(myCallable);
            //new Thread
            new Thread(task).start();
    
    
            //main线程也启动
            for (int i = 0; i < 10; i++) { 
                if(i>=5){ 
                    try { 
                        Thread.sleep(2000);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
                System.out.println("我是main线程："+Thread.currentThread().getName());
            }
    
            //call方法 返回的接口
            try { 
                final Boolean aBoolean = task.get();
                System.out.println("返回的结果："+aBoolean);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            } catch (ExecutionException e) { 
                e.printStackTrace();
            }
        }
    
    }
    
    //定义类实现Callable接口
    class MyCallable implements Callable{ 
        //重写call方法
        @Override
        public Boolean call() throws Exception { 
            for (int i = 0; i < 10; i++) { 
                System.out.println("我是线程："+Thread.currentThread().getName()+":"+i);
            }
            return true;
        }
    }

Callable 和 Future接口的区别：

（1）Callable规定的方法是call()，而Runnable规定的方法是run().  
（2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。  
（3）call()方法可抛出异常，而run()方法是不能抛出异常的。  
（4）运行Callable任务可拿到一个Future对象， Future表示异步计算的结果。 它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。 通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。  
Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。

运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1aHVpMjEwMA_size_16_color_FFFFFF_t_70]  
注：上面三种只是单纯的启动多个线程，并不安全！！！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1aHVpMjEwMA_size_16_color_FFFFFF_t_70]: /images/20221022/0a2b0d0c8b5c495eabd9f380f32abdd8.png