并发、并行
并发:在同一时刻,有多个指令在单个CPU上交替执行
并行:在同一时刻,有多个指令在多个CPU上同时执行
多线程的实现方式
1、继承Thread类的方式进行实现:
实现步骤:
1、自己定义一个类MyThread继承Thread
2、重写run方法
3、创建子类对象,并启动线程
代码实现:
package com.liming.mythread01;
public class ThreadDemo {
public static void main(String[] args) {
/*
* 1. 自己定义一个类继承Thread
* 2. 重写run方法
* 3. 创建子类对象,并启动线程
* */
// 3步骤
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
t1.setName("线程1");//分清线程,交替执行
t2.setName("线程2");
t1.start();
t2.start();
}
}
package com.liming.mythread01;
public class MyThread extends Thread{
// 1、2步骤
@Override
public void run() {
//书写要执行的代码
for (int i = 0; i < 100; i++) {
System.out.println(getName()+"HelloWorld");
}
}
}
2、实现Runnable接口的方式进行实现:
实现步骤:
1、自己定义类MyRun实现Runnable接口
2、重写里面的run方法
3、创建自己类的对象
4、创建一个Thread类的对象,并开启线程
代码实现:
package com.liming.mythread02;
public class ThreadDemo {
public static void main(String[] args) {
/*
* 1. 自己定义一个类MyRun实现Runnable接口
* 2. 重写里面的run方法
* 3. 创建自己的类的对象
* 4. 创建一个Thread类的对象,并开启线程
* */
//3步骤,创建MyRun对象,表示多线程要执行的任务
MyRun mr = new MyRun();
//4步骤
Thread t1 = new Thread(mr);
Thread t2 = new Thread(mr);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
package com.liming.mythread02;
public class MyRun implements Runnable {
//1、2步骤
@Override
public void run() {
for (int i = 0; i < 100; i++) {
//获取到当前线程的对象,用对象获取名称
/*Thread t = Thread.currentThread();
System.out.println(t.getName()+"HelloWorld");*/
System.out.println(Thread.currentThread().getName() + "HelloWorld");
}
}
}
3、利用Callable接口和Future接口方式实现:
实现步骤:
1、创建一个MyCallable类实现Callable接口
2、重写call方法(是有返回值的,表示多线程运行的结果)
3、创建MyCallable的对象(表示多线程要执行的任务)
4、创建FutureTask的对象(管理多线程运行的结果)
5、创建Thread类的对象并启动(表示线程)
代码实现:
package com.liming.mythread03;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class ThreadDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
/*
* 1. 创建一个类MyCallable实现Callable
* 2. 重写call(是有返回值的,表示多线程运行的结果)
* 3. 创建MyCallable的对象(表示多线程要执行的任务)
* 4. 创建FutureTask的对象(作用管理多线程运行的结果)
* 5. 创建Thread类的对象并启动(表示线程)
* */
//3步骤
MyCallable mc = new MyCallable();
//4步骤
FutureTask<Integer> ft = new FutureTask<>(mc);
//5步骤
Thread t = new Thread(ft);
t.start();
//获取多线程运行的结果
Integer result = ft.get();
System.out.println(result);
}
}
package com.liming.mythread03;
import java.util.concurrent.Callable;
public class MyCallable implements Callable<Integer> {
//1、2步骤
@Override
public Integer call() throws Exception {
//求1-100的合
int sum = 0;
for (int i = 0; i < 100; i++) {
sum += i;
}
return sum;
}
}
多线程三种实现方式对比
方式 | 优点 | 缺点 |
---|---|---|
继承Thread类 | 编程简单,可以直接使用Thread类中的方法 | 扩展性差,不能在继承其他的类,不能返回线程执行的结果 |
实现Runnable接口 | 扩展性强,实现该接口的同时还可以继承其他的类 | 编程相对复杂,不能返回线程执行的结果 |
实现Callable接口 | 扩展性强,实现该接口的同时还可以继承其他的类。可以得到线程执行的结果 | 编程相对复杂 |