Java实现多线程方式

最新推荐文章于 2024-09-19 06:14:12 发布

Teeny-TinyIT

最新推荐文章于 2024-09-19 06:14:12 发布

阅读量663

点赞数 17

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_59500811/article/details/140153338

版权

一、继承Thread类

1. 自定义一个类，继承extends Thread类

2. 重写run()，并指定执行任务

3. 通过new创建线程对象，并由start() 启动线程

优势：代码简洁；

劣势：单继承，一旦继承Thread类，就不可以再继承其他类拓展性不好。

class MyThread extends Thread{
    public MyThread(String name){
        super(name);
    }

    //定义执行的任务
    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            Thread thread = Thread.currentThread();
            System.out.println(thread+" : "+i);
        }
    }
}

public class ThreadDemo {

    //打印输出线程信息  Thread[线程名字 , 线程优先级 , 所属的线程组]
    public static void main(String[] args) {
       
        MyThread my = new MyThread("T1"); //副线程

        my.start();    //start() 才是真正启动当前线程my的方法
       
        //my.run();    //run() 并不是启动当前线程my，由main主线程去执行任务
        

        //这就是main主线程的任务
        for (int i = 0; i <10 ; i++) {
            Thread thread = Thread.currentThread();
            System.out.println(thread+" : "+i);
        }

        /*System.out.println(my);   //Thread[T1,5,main]
        Thread main = Thread.currentThread();
        System.out.println(main); //Thread[main,5,main]*/
    }

}

二、实现 Runnable接口

1. 自定义一个任务类，实现implements Runnable接口

2. 重写run()，并指定执行任务

3. 通过new创建线程对象，并由start() 启动线程

优势：

解决了Java单继承带来的局限；

允许创建多条线程，执行同一个任务；

线程池中只能放入Runnable或Callable的实例

增强了程序的拓展性，实现解耦操作，降低耦合度：多个线程可以共享同一个任务的代码快，但任务代码和线程独立。

劣势：相比较于第一种较为繁琐。

class MyRunnable implements Runnable{
    //制定执行的任务
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() +" : "+i);
        }
    }
}

public class RunnableDemo {

    public static void main(String[] args) {
        //创建任务
        MyRunnable myRun = new MyRunnable();

        //创建线程，并传入任务，启动线程
        new Thread(myRun , "t1").start();
        new Thread(myRun , "t2").start();

        //主线程执行如下任务
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread() +" : "+i);
        }
    }

}

三、实现 Callable接口

1. 自定义一个类，实现implements Callable接口

2. 重写call()，并指定执行的任务

3. 创建Callable 对象

4. 创建FutureTask任务对象，并传入Callable对象

5. 通过new创建线程对象，传入FutureTask任务对象，并由start()启动线程

6. 通过FutureTask对象，get()获取执行完毕后的结果

优势：

解决了Java单继承带来的局限；

允许创建多条线程，执行同一个任务；

线程池中只能放入Runnable或Callable的实例

增强了程序的拓展性，实现解耦操作，降低耦合度：多个线程可以共享同一个任务的代码快，但任务代码和线程独立。

劣势：相比较于第一种较为繁琐。

public class CallableDemo {

    public static void main(String[] args) {
        //创建Callable对象
        MyCallable MyCall = new MyCallable();

        //创建FutureTask对象，将来获取执行任务后的结果
        //FutureTask 间接实现 Runnable接口
        FutureTask task1 = new FutureTask(MyCall);
        FutureTask task2 = new FutureTask(MyCall);

        //创建线程，启动线程，执行任务
        new Thread(task1 , "线程1").start();
        new Thread(task2 , "线程2").start();

        //获取当前任务的返回值
        try {
            String string1 = task1.get().toString();
            System.out.println("string1 = "+string1);
            String string2 = task2.get().toString();
            System.out.println("string2 = "+string2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}
class MyCallable implements Callable<String>{

    //制定的执行的任务，可以携带返回值
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            sum+=i;
            System.out.println(Thread.currentThread().getName()+" : "+i );
        }
        return Thread.currentThread().getName()+" , sum = "+sum;
    }
}