认识多线程

最新推荐文章于 2024-08-08 09:40:13 发布

qq_21841877

最新推荐文章于 2024-08-08 09:40:13 发布

阅读量94

点赞数

分类专栏： Java 文章标签： Java 多线程

Java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1、多线程有什么作用？

发挥多核CPU的优势
防止阻塞

2、Java实现多线程的四种方式

继承Thread类，重写run()方法；
实现Runnable接口，重写run()方法；
实现Callable接口，实现call()方法，通过FutureTask包装器来创建线程；
使用ExecutorService、Callable、Future实现有返回结果的多线程；

以上四种实现方式可以归结为两类：
前面两种可以归结为一类：无返回值，原因很简单，通过重写run方法，run方式的返回值是void，所以没有办法返回结果。
后面两种可以归结成一类：有返回值，通过Callable接口，就要实现call方法，这个方法的返回值是Object，所以返回的结果可以放在Object对象中。

实现方式一：继承Thread类，重写run()方法
Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extends Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。

public class ThreadTest extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(getName() + "--->" + i);
		}
	}

	public static void main(String[] args) {
		for (int i = 0; i < 50; i++) {
			System.out.println(Thread.currentThread().getName() + "->" + i);
			if (i == 20) {
				new ThreadTest().run();
				new ThreadTest().run();
			}
		}
	}
}

实现方式二：实现Runnable接口，重写run()方法
由于Java的单继承特性，若当前类已经继承其他类，此时便可以通过实现Runnable接口+重写run()方法实现多继承。

public class ThreadTest implements Runnable {
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() + "--->" + i);
		}
	}

	public static void main(String[] args) {
		for (int i = 0; i < 50; i++) {
			System.out.println(Thread.currentThread().getName() + "->" + i);
			if (i == 20) {
				new ThreadTest().run();
				new ThreadTest().run();
			}
		}
	}
}

以上两种实现多线程方式的异同：
1、实现多线程无返回值，原因：重写的run()方法无返回值。
2、适合多个相同的程序代码的线程去处理同一资源。
3、继承Thread类会受Java单继承的限制。
4、通过继承Thread类重写run()创建的线程不能放入线程池中，通过实现Runnable接口和Callable接口创建的线程可以放入线程池中。
实现方式三：实现Callable接口，通过FututreTask创建线程
1、创建Callable接口的实现类，并实现call()方法；
2、创建Callable实现类的实现，使用FutureTask类包装Callable对象，该Callable对象封装了Callable对象的call()方法的返回值；
3、使用FutureTask对象作为Thread对象的target创建并启动新线程；
4、调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。


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

public class ThreadTest {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		// 创建实现Callable接口并重写call()方法的对象
		ThreadCallable tc = new ThreadCallable();
		// 使用FutureTask类包装Callable对象
		FutureTask<Object> ft = new FutureTask<Object>(tc);
		System.out.println(Thread.currentThread().getName());
		// 将ThreadTask对象作为Thread对象的Target，创建线程并启动线程
		Thread t = new Thread(ft);
		t.start();
		// 调用FutureTask的get()方法获取子线程执行结果的返回值
		Object obj = ft.get();
		System.out.println(((User) obj).getName());
		System.out.println(Thread.currentThread().getName());

	}
}

class ThreadCallable implements Callable<Object> {
	@Override
	public Object call() throws Exception {
		System.out.println(Thread.currentThread().getName() + "--->" + "实现Callable接口，重写call方法");
		return new User("Jack", 12);
	}
}

实现方式四：通过线程池实现

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolTest {
	private static int POOL_SIZE = 10;

	public static void main(String[] args) {
		ExecutorService executorService = Executors.newFixedThreadPool(5);
		for (int i = 0; i < POOL_SIZE; i++) {
			RunnableThread thread = new RunnableThread();
			executorService.execute(thread);
		}
	}
}

class RunnableThread implements Runnable {
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("线程" + Thread.currentThread() + " " + i);
		}
	}
}

Executor框架
Executor框架是一个任务的执行和调度的框架，将任务的提交过程与执行过程解耦，用户只需定义好任务提交，具体如何执行，什么时候执行不需要关心。Executor框架主要由以下三部分组成：
（1）任务：实现Callable接口或Runnable接口的类，其实例就可以成为一个任务提交给ExecutorService去执行：其中Callable任务可以返回执行结果，Runnable任务无返回结果。

（2）任务的执行：包括任务执行机制的核心接口Executor，以及继承自Executor的ExecutorService接口。Executor框架有两个关键类实现了ExecutorService接口：ThreadPoolExecutor 和 ScheduledThreadPoolExecutor；

（3）任务的异步计算结果：包括Future接口和实现Future接口的FutureTask类、ForkJoinTask类。
使用步骤：把任务，如Runnable接口或Callable接口的实现类提交（submit）给线程池执行，如ExecutorService、ThreadPoolExecutor、ScheduledThreadPoolExecutor等。线程池会返回一个异步计算结果，即Future对象，然后调用Future的get方法等待执行结果即可。
在这里插入图片描述
另外，还有一个Executors类，它是一个工具类（有点类似集合框架的Collections类），用于创建ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable对象。

2、Java线程池中submit()和execute()方法有什么区别？

两个方法都可以向线程池提交任务，execute()方法的返回类型是void，它定义在Executor接口中, 而submit()方法可以返回持有计算结果的Future对象，它定义在ExecutorService接口中，它扩展了Executor接口，其它线程池类像ThreadPoolExecutor和ScheduledThreadPoolExecutor都有这些方法。

3、常用的4种线程池
（1）newSingleThreadExecutor：

创建一个单线程的线程池。这个线程池只有一个线程在工作，串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

适用场景:适用于需要保证顺序地执行各个任务；并且在任意时间点，不会有多个线程活动的应用场景。

（2）newFixedThreadPool：

创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大容量。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

适用场景：为了满足资源管理的需求，而需要限制当前线程数量的应用场景，它适用于负载比较重的服务器。

（3）newCachedThreadPool：

创建一个可缓存的线程池，大小不受限。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（即60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

适用场景：适用于执行很多的短时间异步任务的小程序，或者是负载较轻的服务器。

（4）newScheduledThreadPool：

创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

4、线程控制方法
1、线程中sleep()方法和wait方法的区别？

（1）sleep()使当前线程进入睡眠状态，让出CPU的使用，目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会，但是该线程仍然占有该锁，其他线程无法访问这个对象。在sleep()休眠时间期满后，该线程不一定会立即执行，因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。

（2）wait()方法是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时释放对象锁（wait(long timeout)超时时间到后还需要返还对象锁）；其他线程可以访问该对象锁；wait()可以使用notify或者notifyAll()或者指定睡眠时间来唤醒当前等待池中的线程。notify()和notifyAll()方法只是随机唤醒等待该对象锁的线程，并不决定哪个线程能够获取到锁。

2、start()方法和run()方法的区别：

只有调用了start()方法，才会表现出多线程的特性，不同线程的run()方法里面的代码交替执行。如果只是调用run()方法，那么代码还是同步执行的，必须等待一个线程的run()方法里面的代码全部执行完毕之后，另外一个线程才可以执行其run()方法里面的代码。

3、thread类中的yield方法有什么作用？

yield()方法可以暂停当前正在执行的线程对象，让其它有相同优先级的线程执行。执行yield()的线程有可能在进入到暂停状态后马上又被执行。

4、Thread.sleep(0)的作用是什么：

由于Java采用抢占式的线程调度算法，因此可能会出现某条线程常常获取到CPU控制权的情况，为了让某些优先级比较低的线程也能获取到CPU控制权，可以使用Thread.sleep(0)手动触发一次操作系统分配时间片的操作，这也是平衡CPU控制权的一种操作。

5、如何在两个线程之间共享数据：

通过在线程之间共享对象，然后通过wait/notify/notifyAll、await/signal/signalAll进行唤起和等待，比方说阻塞队列BlockingQueue就是为线程之间共享数据而设计的。

6、为什么wait()方法和notify()/notifyAll()方法要在同步块中被调用：

这是JDK强制的，wait()方法和notify()/notifyAll()方法在调用前都必须先获得对象的锁

7、wait()方法和notify()/notifyAll()方法在放弃对象监视器时有什么区别：

wait()方法和notify()/notifyAll()方法在放弃对象监视器的时候的区别在于：wait()方法立即释放对象监视器，notify()/notifyAll()方法则会等待线程剩余代码执行完毕才会放弃对象监视器。