java多线程的3种实现方式
Posted zhiwenxi
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java多线程的3种实现方式相关的知识,希望对你有一定的参考价值。
多线程相关的问题
1.什么是进程?
? 正在执行的程序
2.什么是线程?
? 进程的子单位,一个能够完成独立功能的执行路径
3.为什么需要开启多线程?
- 当执行某些耗时操作的任务的时候需要开启多线程,防止线程阻塞
- 能够让两个任务看起来像是在同时执行
- 提高CPU的使用率,进而提高进程和内存的使用率
4.为什么开启多线程会同时执行?
? 因为CPU切换执行的速度太快了,肉眼无法差距
5.开启多线程是不是越多越好,提高了效率还是降低了效率?
? 不是,线程越多,效率越慢,但是太少,浪费CPU资源,所以,合理利用CPU
6.并发和并行的区别
- 并发 --> 在同一个时间段下同时执行多个线程,看起来像同时执行
- 并行 --> 在同一个时间刻度下(不能够在分割的时间单位)执行多个线程,本质就上就是同时执行
CPU在某一个最小的时间刻度单位下,执行的是一个进程的一个线程的一个不可再分割的原子性语句
线程开启方式
Java提供了三种创建线程方法:
? 1.继承Thread类的方式
? 2.实现Runnable的方式
? 3.通过 Callable 和 Future 创建线程。
方式一:继承Thread类
? 1.自定义类MyThread继承Thread类。3
? 2.MyThread类里面重写run()方法。
? 3.创建线程对象。
? 4.启动线程。
注意:
? 1、启动线程使用的是start()方法而不是run()方法
? 2、线程能不能多次启动线程对象调用 run方法和调用start方法区别?
- 线程对象调用run方法不开启线程。仅是对象调用方法。
- 线程对象调用start开启线程,并让jvm调用run方法在开启的线程中执行
代码演示使用方式一开启线程
// 方式二:实现Runnable接口
class CalculateRunnable implements Runnable
private int m;
private int n;
public CalculateRunnable(int m, int n)
super();
this.m = m;
this.n = n;
public CalculateRunnable()
super();
@Override
public void run()
int sum = 0;
for (int i = m; i <= n; i++)
sum += i;
System.out.println("CalculateRunnable子线程: " + i);
System.out.println(m + "~" + n + "的和: " + sum);
方式二:实现Runnable接口
? 1.自定义类MyRunnable实现Runnable接口
? 2.重写run()方法
? 3.创建MyRunnable类的对象
? 4.创建Thread类的对象,并把步骤3创建的对象作为构造参数传递
? 5.启动线程实现接口方式的好处
可以避免由于Java单继承带来的局限性。
适合多个相同程序的代码去处理同一个资源的情况,把线程同程序的代码,数据有效分离,较好的体现了面向对象的设计思想。代码演示方式二开启线程
// 方式一:继承Thread类
class CopyThread extends Thread
private File srcFile;
private File descFile;
public CopyThread()
super();
public CopyThread(File srcFile, File descFile)
super();
this.srcFile = srcFile;
this.descFile = descFile;
@Override
public void run()
// main方法怎么写,这里就怎么写
copy(srcFile, descFile);
public void copy(File srcFile, File descFile)
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(descFile)))
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1)
bos.write(bys, 0, len);
bos.flush();
catch (FileNotFoundException e)
e.printStackTrace();
catch (IOException e)
e.printStackTrace();
主方法调用
public static void main(String[] args)
CopyThread ct = new CopyThread(new File("Test.java"), new File("Test.txt"));
CalculateRunnable cr = new CalculateRunnable(1, 200);
Thread t = new Thread(cr);
ct.start();
t.start();
for (int i = 0; i < 100; i++)
System.out.println("main线程: " + i);
方式三: Callable 和 Future 创建线程。
- 创建 Callable 接口的实现类,并实现 call() 方法,该 call() 方法将作为线程执行体,并且有返回值。
- 创建 Callable 实现类的实例,使用 FutureTask 类来包装 Callable 对象,该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
- 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
- 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。
继承Thread和实现Runnable的方式的特点:
? 1.没有返回结果
? 2.没有异常
Callable和Runnable的区别:
? 1.Runnable无返回值,没有异常抛出的
? 2.Callable可以在启动线程中获取返回值, 以及接受子线程的异常
线程间的数据传递:线程通信
? A线程中开启了B线程
? A --> B 通过构造方法
? B --> A 通过Callable方式
public class CallableDemo
public static void main(String[] args)
FutureTask<Integer> task = new FutureTask<>(new CalculateCallable(0,100));
Thread t = new Thread(task);
t.start();
try
Integer i = task.get();
System.out.println("计算结果: " + i);
catch (InterruptedException | ExecutionException e)
e.printStackTrace();
catch (Exception e)
e.printStackTrace();
System.out.println("程序结束");
class CalculateCallable implements Callable<Integer>
private int m;
private int n;
public CalculateCallable()
super();
public CalculateCallable(int m, int n)
super();
this.m = m;
this.n = n;
@Override
public Integer call() throws Exception
int sum = 0;
for (int i = m; i <= n; i++)
System.out.println("子线程: " + i);
sum += i;
throw new NullPointerException("空指针异常!");
return sum;
以上是关于java多线程的3种实现方式的主要内容,如果未能解决你的问题,请参考以下文章