Java中的多线程

目录

1、理解线程和多线程

2、多线程的创建

Thread类

多线程的实现方案一：继承Thread类

 多线程的实现方案二：实现Runnable接口

 多线程的实现方案二：实现Runnable接口(匿名内部类形式)

多线程的实现方案三：利用Callable、FutureTask接口实现。 

 3种方式对比

---

1、理解线程和多线程

什么是线程？

线程(thread)是一个程序内部的一条执行路径。

我们启动程序执行后，main方法的执行其实就是一条单独的执行路径。

程序中如果只有一条执行路径，那么这个程序就是单线程的程序。

如：

public static void main(String[] args) {
   // 代码
    for (int i = 0; i < 10; i++) {
       System.out.println(i);    
    }
    // 代码...
}

多线程是什么？

多线程是指从软硬件上实现多条执行流程的技术。

2、多线程的创建

Thread类

多线程的实现方案一：继承Thread类

具体代码实现： 

public class ThreadDemo1 {
    public static void main(String[] args) {
        //2、new一个新线程对象
        Thread t = new MyThread();
        //3、调用start方法启动线程（执行的还是run()方法
        t.start();
 
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出：" + i);
        }
    }
}
 
 
//1、定义一个子类MyThread继承线程类java.lang.Thread，
class MyThread extends Thread{
 
    //重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
}

 多线程的实现方案二：实现Runnable接口

具体代码实现： 

public class RunnableDemo1 {
    public static void main(String[] args) {
        //2、创建一个任务对象
        MyRunnable target = new MyRunnable();
        //3、把任务对象交给Thread处理
        Thread t = new Thread(target);
        //4、启动线程
        t.start();
 
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出：" + i);
        }
    }
}
 
//1、定义一个线程任务类MyRunnable实现Runnable接口
class MyRunnable implements Runnable{
    //重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
}

 多线程的实现方案二：实现Runnable接口(匿名内部类形式)

具体代码实现： 

public class RunnableDemo2 {
    public static void main(String[] args) {
 
        //写法1，子线程1
        Runnable target = new Runnable() {
           @Override
           public void run() {
               for (int i = 0; i < 5; i++) {
                   System.out.println("子线程1执行输出：" + i);
               }
           }
        };
        Thread t = new Thread(target);
        t.start();
 
        //写法2，子线程2
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程2执行输出：" + i);
                }
            }
        }).start();
 
        //写法3，子线程3
        new Thread(() -> {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程3执行输出：" + i);
                }
        }).start();
 
        //主线程
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出：" + i);
        }
    }
}

1、前2种线程创建方式都存在一个问题：

2、怎么解决这个问题呢？

多线程的实现方案三：利用Callable、FutureTask接口实现。 

具体代码实现： 

public class CallableDemo1 {
    public static void main(String[] args) {
        //3、创建Callable任务对象
        Callable<String> call = new MyCallable(100);
        //4、把Callable任务对象 交给FutureTask对象
            //  FutureTask对象的作用1：是Runnable的对象（实现了Runnable的接口），可以交给Thread了
            //  FutureTask对象的作用2：可以在线程执行完毕之后通过调用其get()方法得到线程执行完成的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        //5、交给线程处理
        Thread t = new Thread(f1);
        //6、启动线程
        t.start();
 
        Callable<String> call1 = new MyCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call1);
        Thread t1 = new Thread(f2);
        t1.start();
 
        try {
            //如果f1任务没有执行完毕，这里的代码回等待，直到线程1跑完才提取结果
            String s1 = f1.get();
            System.out.println("第一个结果：" + s1);
        } catch (Exception e) {
            e.printStackTrace();
        }
 
        try {
            //如果f2任务没有执行完毕，这里的代码回等待，直到线程2跑完才提取结果
            String s2 = f2.get();
            System.out.println("第二个结果：" + s2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
 
//1、定义一个任务类实现Callable接口， 应该声明线程任务类执行完毕后的结果的数据类型
class MyCallable implements Callable<String>{
 
    private int n;
 
    public MyCallable(int n) {
        this.n = n;
    }
 
    //重写call()方法（任务方法）
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return "子线程执行的结果是:" + sum;
    }
}

 3种方式对比