多线程的实现方式

news2024/9/23 3:24:43

点击链接返回标题->

Java线程的学习-CSDN博客

第一种方式，继承Thread类

Thread类是java.lang包下的类，是多线程经常需要使用的类。

①通过自定义子类去继承Thread类，并重写其中的run()方法。

class myThread extends Thread {//自定义子类myThread继承Thread类

@Override
public void run() {//重写run()方法
for (int i = 1; i <= 100; i++) {
System.out.println(getName() + "打印了" + i);//
}
}
}

②用自定义子类实例化对象t，这个对象t就是一个线程，并调用对象t的start()方法，启动该线程。

myThread t1 = new myThread();//实例化对象，线程t1
myThread t2 = new myThread();//实例化对象，线程t2

t1.start();//启动线程t1

t2.start();//启动线程t2

③可以调用对象t的setName()方法，给线程命名，如果不命名，默认线程名为Thread-0、Thread-1...调用getName()方法获取当前线程名

t1.setName("线程1");//设置线程t1的名字
t2.setName("线程2");//设置线程t2的名字

示例代码——

public class Main {
    public static void main(String[] args) {
        myThread t1 = new myThread();//实例化对象，线程t1
        myThread t2 = new myThread();//实例化对象，线程t2

        t1.setName("线程1");//设置线程t1的名字
        t2.setName("线程2");//设置线程t2的名字

        t1.start();//启动线程t1
        t2.start();//启动线程t2
    }
}

class myThread extends Thread {//自定义子类myThread继承Thread类

    @Override
    public void run() {//重写run()方法
        for (int i = 1; i <= 100; i++) {
            System.out.println(getName() + "打印了" + i);//
        }
    }
}

这里展现出部分运行结果，可以看到，cpu在执行这段代码时，在线程1和线程2之间反复切换（执行线程1还是线程2，是随机的！）

第二种方式，实现Runnable接口

Runnable接口是java.lang包下的接口

在大多数情况下，如果只打算重写run()方法而不使用其他Thread方法，则应使用Runnable接口

①通过自定义子类去实现Runnable接口，并重写其中的run()方法。

class MyRun implements Runnable {
public void run() {
for (int i = 1; i <= 100; i++) {
System.out.println("MyThread类的run()方法在运行");
}
}
}

②用自定义子类实例化对象mr，这个mr现在还不是线程，而是线程要执行的任务。

MyRun mr = new MyRun();

③用Thread类实例化对象t，并传入mr实现有参构造，这个t才是线程，用start()方法启动线程。

//Thread类传入MyRun的对象通过有参构造实例化对象
Thread t1 = new Thread(mr);
Thread t2 = new Thread(mr);

t1.start();
t2.start();

④同样的，可以调用对象t的setName()方法，给线程命名，但是——因为这个自定义子类是实现Runnable接口而不是继承Thread类，所以在自定义子类中不能直接调用Thread类的getName()方法获取线程名字。解决方法是，在这个自定义类中用Thread类中的一个静态方法Thread.currentThread()，获取当前线程的实例化对象，然后调用这个对象的方法。

class MyRun implements Runnable {
public void run() {
Thread th = Thread.currentThread();//获取当前线程的实例化对象
for (int i = 1; i <= 100; i++) {
System.out.println(th.getName() + "MyThread类的run()方法在运行");
}
}
}

示例代码——

public class Main {
    public static void main(String[] args) {
        MyRun mr = new MyRun();
        //Thread类传入MyRun的对象通过有参构造实例化对象
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);

        //设置线程名字
        t1.setName("线程1");
        t2.setName("线程2");

        //启动线程
        t1.start();
        t2.start();
    }
}

class MyRun implements Runnable {
    public void run() {
        Thread th = Thread.currentThread();//获取当前线程的实例化对象
        for (int i = 1; i <= 100; i++) {
            System.out.println(th.getName() + "MyThread类的run()方法在运行");
        }
    }
}

部分运行结果——

第三种方式，实现Callable接口

我们发现前两种方式都是通过重写run()方法的形式来实现，但这个run()方法的返回值却是void类型的，也就是说，我们无法通过返回值获取多线程中的运行结果。

假如线程A执行一个运算任务，线程B需要获取线程A的运算结果，这该如何实现呢？

Callable接口是java.util.concurrent包下的接口，它的特点是可以获取到多线程运行的结果。

①通过自定义子类去实现Callable接口，并重写call()方法，call()方法必须声明抛出异常。

有关Java异常详见本篇->Java异常-CSDN博客

class mycall implements Callable<Integer> {//这个<Integer>是声明泛型的返回值是整数
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}

②用自定义子类实例化对象mc，这个mc现在还不是线程，而是线程要执行的任务。

mycall mc = new mycall();

③用FutureTask类去实例化对象ft，这个对象用来管理线程的返回值。

FutureTask<Integer> ft = new FutureTask<>(mc);

④用Thread类创建线程对象t，传入管理线程任务的对象ft实现有参构造，并调用对象t的start()方法启动线程。

Thread t1 = new Thread(ft);

Thread t2 = new Thread(ft);

t1.start();

t2.start();

⑤调用ft的get()方法获取对应线程的运行结果，这个结果可以作为数据按实际需求使用。

Integer res1 = ft.get();

Integer res2 = ft.get();

System.out.println(res1 + res2);

示例代码——

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {//此处方法需要注意声明抛出异常
        mycall mc = new mycall();
        FutureTask<Integer> ft = new FutureTask<>(mc);
        Thread t1 = new Thread(ft);
        Thread t2 = new Thread(ft);
        t1.start();
        t2.start();
        Integer res1 = ft.get();
        Integer res2 = ft.get();
        System.out.println(res1 + res2);
    }
}

class mycall implements Callable<Integer> {//这个<Integer>是声明泛型的返回值是整数

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}