概念
进程:程序的基本执行实体
线程:操作系统能够进行运算调度的最小单位,被包含在进程之中,是进程的实际运作单位
并发:同一时刻,多个指令在单个CPU上交替执行。
并行:同一时刻,多个指令在多个CPU上同时执行。
多线程第一种实现方式——重写run方法
test代码:
public class test {
public static void main(String[] args) {
/*
* 多线程的第一种启动方式:
* 1.自己重新定义一个类继承Thread
* 2.重写run方法
* 3.创建子类对象并启动线程
* */
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
线程类代码:MyThread
public class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(getName() + "hello");
}
}
}
多线程第二种实现方式——实现runable接口
test代码
public class test2 {
public static void main(String[] args) {
/*
* 多线程第二种启动方式:
* 1.自己定义一个类实现Runable接口
* 2.重写里面的run方法
* 3.创建自己的类方法
* 4.创建一个Thread类的对象,开启线程
* */
// 创建MyRun对象
MyRun mr = new MyRun();
// 创建线程对象
Thread t1 = new Thread(mr);
Thread t2 = new Thread(mr);
t1.setName("线程1");
t2.setName("线程2");
// 开启线程
t1.start();
t2.start();
}
}
runable接口代码
package test614;
public class MyRun implements Runnable {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "hello");
}
}
}
多线程第二种实现方式——实现Callable接口和Future接口方式实现
test代码
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class test3 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
/*
* 第3种实现方式:
* 特点:可以获取到多线程的运行结果
* 1.创建一个类MyCallable实现Callable接口
* 2.重写call(有返回值,表示多线程的运行结果)
* 3.创建MyCallable对象,表示多线程要执行的任务
* 4.创建Future的对象(作用管理多线程运行的结果)
* 5.创建Thread的对象并启动(表示线程)
* */
MyCallable mc = new MyCallable();
FutureTask<Integer> ft = new FutureTask<Integer>(mc);
new Thread(ft).start();
Integer result = ft.get();
System.out.println(result);
}
}
MyCallable代码
import java.util.concurrent.Callable;
public class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 100; i++) {
sum += i;
}
return sum;
}
}