Java多线程的几种实现方法?说明它们的异同.

说起java多线程编程，大家都不陌生，下面我就总结下java里实现多线程的集中方法：继承Thread类,实现Runnable接口,使用Callable和Future创建线程,使用线程池创建（使用java.util.concurrent.Executor接口）

1.继承Thread类创建线程

通过继承Thread类来创建并启动多线程的一般步骤如下：

  1. 定义Tread类的子类MyThread，并重写run()方法.run()方法的方法体（线程执行体）就是线程要执行的任务。
  2. 创建MyThread类的实例
  3. 调用子类实例的start()方法来启动线程

示例代码:

public class Mythread extends Thread {
	
	private int i;
	public void run(){//run()是线程类的核心方法
		for(int i=0;i<10;i++){
			System.out.println(this.getName()+":"+i);
		}
	}
	public static void main(String[] args) {
		Mythread t1=new Mythread();
		Mythread t2=new Mythread();
		Mythread t3=new Mythread();
		t1.start();
		t2.start();
		t3.start();
	}
}

2.实现Runnable接口创建线程

通过实现Runnable接口创建并启动线程的一般步骤如下：

1.定义Runnable接口的实现类，必须重写run(）方法，这个run()方法和Thread中的run()方法一样，是线程的执行体

2.创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象

3.调用start()方法

示例代码:
public class MyThread implements Runnable{

@Override
public void run() {
	for(int i=0;i<10;i++){
		System.out.println(Thread.currentThread().getName()+" : "+i);
	}
	
}
public static void main(String[] args) {
	MyThread myThread=new MyThread();
	Thread thread1=new Thread(myThread,"线程1");
	Thread thread2=new Thread(myThread,"线程2");
	Thread thread3=new Thread(myThread,"线程3");
	thread1.start();
	thread2.start();
	thread3.start();
}

}

3.覆写Callable接口实现多线程

它虽然也是接口,但和Runnable接口不一样，Callable接口提供了一个call()方法作为线程执行体，call()方法比run()方法功能要强大:

1.call方法可以有返回值
2.call()方法可以声明抛出异常

创建并启动有返回值的线程的步骤如下：

1.创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例（从java8开始可以直接使用Lambda表达式创建Callable对象）。

2.使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值

3.使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口）

4.调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

示例代码:

public class MyThread implements Callable<String>{//Callable是一个泛型接口
 
	@Override
	public String call() throws Exception {//返回的类型就是传递过来的V类型
		for(int i=0;i<10;i++){
			System.out.println(Thread.currentThread().getName()+" : "+i);
		}
		
		return "Hello DengFengZi";
	}
	public static void main(String[] args) throws Exception {
		MyThread myThread=new MyThread();
		FutureTask<String> futureTask=new FutureTask<>(myThread);
		Thread t1=new Thread(futureTask,"线程1");
		Thread t2=new Thread(futureTask,"线程2");
		Thread t3=new Thread(futureTask,"线程3");
		t1.start();
		t2.start();
		t3.start();
		System.out.println(futureTask.get());
	}
}

FutureTask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。 FutureTask可以确保即使调用了多次run方法，它都只会执行一次Runnable或者Callable任务，或者通过cancel取消FutureTask的执行等。

疑问:

同时实现Runnable和Callable接口会怎么样？

结论:使用Runnable接口实现类做target创建的的线程和FutureTask的线程交叉着运行，但是由于FutureTask只执行一次Callable任务，在一次运行结束后就终止了程序。

4.使用线程池例如用Executor框架

什么是Executor框架?

Executor框架包括：线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等。

具体内容可以到我这篇博客查看
Executor执行Runnable任务
通过Executors的以上四个静态工厂方法获得 ExecutorService实例，而后调用该实例的execute（Runnable command）方法即可。一旦Runnable任务传递到execute（）方法，该方法便会自动在一个线程上

示例代码:

import java.util.concurrent.ExecutorService;   
import java.util.concurrent.Executors;   
  
public class TestCachedThreadPool{   
    public static void main(String[] args){   
        ExecutorService executorService = Executors.newCachedThreadPool();   
        for (int i = 0; i < 3; i++){  //执行三个任务，那么线程池中最多创建三个线程
            executorService.execute(new TestRunnable());   
            System.out.println("************* a" + i + " *************");   
        }   
        executorService.shutdown();   
    }   
}   
  
class TestRunnable implements Runnable{   
    public void run(){   
    	for(int i=0;i<5;i++){
    		 System.out.println(Thread.currentThread().getName() + "线程被调用了。");   
    	}
    }   
}

当通过实现Callable接口创建线程时，调用了Future接口的实现类FutureTask,该类还实现了Runnable接口，所以可以让实例化对象作为Thread对象的Target。并且每次只执行一个线程的任务，当执行完线程的主任务后，返回值。

示例代码:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class RunNewFixedThreadPool {
    public static void main(String[] args) {
    	RunNewFixedThreadPool run = new RunNewFixedThreadPool();
        ExecutorService executorService = Executors.newFixedThreadPool(6);
        for (int i = 0; i < 5; i++) {//创建五个线程
            executorService.execute(run.new MyRunnable(" "+(i+1)));
        }
        for (int i = 5; i < 10; i++) {//再创建五个线程，如果当前线程池中有线程可以使用，则复用，否则创建新的线程，但是线程池中最多只能有6个线程
            executorService.execute(run.new MyRunnable(" "+(i+1)));
        }
    }
    
    public class MyRunnable implements Runnable{
        private String username;
        
        public MyRunnable(String username) {
            this.username = username;
        }
 
 
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+" username="+username+" begin "+System.currentTimeMillis());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" username="+username+" end   "+System.currentTimeMillis());
        }
        
    }
}

这里面每次创建的线程数可以设定，上面设为了5，所以一次性开启了五个线程。如果设为3，那么一次最多开三个进程，并且只有当一些进程关闭时，才会开启相同数目的进程。

总结四种创建线程的方法

实现Runnable和实现Callable接口的方式基本相同，不过是后者执行call()方法有返回值，前者线程执行体run()方法无返回值，并且如果使用FutureTask类的话，只执行一次Callable任务。因此可以把这两种方式归为一种这种方式与继承Thread类的方法之间的差别如下：

1、线程只是实现Runnable或实现Callable接口，还可以继承其他类。

2、这种方式下，多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。

3.继承Thread类只需要this就能获取当前线程。不需要使用Thread.currentThread()方法

4、继承Thread类的线程类不能再继承其他父类（Java单继承决定）。

5、前三种的线程如果创建关闭频繁会消耗系统资源影响性能，而使用线程池可以不用线程的时候放回线程池，用的时候再从线程池取，项目开发中主要使用线程池的方式创建多个线程。

6.实现接口的创建线程的方式必须实现方法（run() call()）。

关于Java创建多线程的四种方式就分享到这里了,感谢各位大佬观看!

posted @ 2021-06-29 20:50  我是一个邓疯子  阅读(378)  评论(0)  编辑  收藏  举报
ヾ(≧O≦)〃嗷~,

这是回到顶部的路哦