java 多线程创建的方式
目录
方式一：继承Thread类
1. 创建一个继承于Thread类的子类
2. 子类重写Thread类的run()方法—>将此线程执行的操作声明在run()中
3. 创建Thread类的子类的对象
4. 通过此对象调用start()方法
/1.创建一个继承于Thread类的子类
class MyThread extends Thread {
//2.重写Thread类的run()方法
@Override
public void run() {
for(int i = 0;i < 100;i++){
if(i % 2 == 0 ){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
//3.创建Thread类的子类的对象
MyThread t1 = new MyThread();
//4.通过此对象调用start()方法:①启动当前线程②调用当前线程的run()
t1.start();
//问题一：我们不能通过直接调用run()的方法启动线
// t1.run();//单纯调run()方法，线程根本没有启动起来，当前还是在主线程里面。
//问题二：再启动一个线程，遍历100以内的偶数。不可以还让已经start()的线程去执行。会报IllegalThreadStateException
// t1.start();
//我们需要重新创建一个线程的对象去调用start()开启新的线程。
MyThread t2 = new MyThread();
t2.start();
//如下操作仍然是在main线程中执行的
for(int i = 0;i < 100;i++){
if(i % 2 == 0 ){
System.out.println(Thread.currentThread().getName() + ":" +i + "********main()***********");
}
}
}
}
方式二：实现Runnable接口
1. 创建一个实现了Runnable接口的类
2. 实现类去实现Runnable中的抽象方法：run()
3. 创建实现类的对象
4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5. 通过Thread类对象调用start(）
//1.创建一个实现了Runnable接口的类
class MThread implements Runnable{
//2.实现类去实现Runnable中的抽象方法：run()
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class ThreadTest1 {
public static void main(String[] args) {
//3.创建实现类的对象
MThread mThread = new MThread();
//4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
Thread t1 = new Thread(mThread);
//5.通过Thread类的对象调用start():①启动线程，②调用当前线程的run()--->调用了Runnable类型的target的run()
t1.setName("线程1");
t1.start();//t1是线程，谁调用start()谁就是线程。
//再启动一个线程，遍历100以内的偶数
Thread t2 = new Thread(mThread);
t2.setName("线程2");
t2.start();
}
}
方式三：实现Callable接口
- 创建一个实习Callable接口的实现类
- 实现call(），将此线程需要执行的操作声明在call()中
- 创建Callable接口实现类的对象
- 将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
- .将FutureTask的对象作为参数传递到Thread类的构造其中，创建Thread对象，并调用start()
- 获取Callable中call方法的返回值
//1.创建一个实现callable接口的实现类
class NumThread implements Callable{
//2.实现call方法，将此线程需要执行的操作声明在call()中。//在抽象方法中，叫实现方法，在继承类关系中，叫重写方法。
@Override
public Object call() throws Exception {//回调方法
int sum = 0;
for (int i = 1; i <=100; i++) {
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;//sum是int类型，使用自动装箱转化为Integer
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);//FutureTask实现接口Future的实现类
//5.将FutureTask的对象作为参数传递到Thread类的构造其中，创建Thread对象，并调用start()
new Thread(futureTask).start();
try {
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum = futureTask.get();
System.out.println("总和为：" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
方式四：使用线程池（ExecutorService 和 Executors）
线程池的使用要配合实现Runable接口或实现Callable接口使用
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
1. void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
2. Future submit(Callable callable)：执行任务，有返回值，一般又来执行Callable
3. void shutdown() ：关闭连接池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
操作步骤：
1.提供指定线程数量的线程池
2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
3.关闭线程池
class NumberThread implements Runnable{
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
//造了10个线程
//创建一个可重用固定线程数的线程池
//1.提供指定线程数量的线程池
//Executors是一个工具类，service是线程池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor)service;
//设置线程池的属性
// System.out.println(service.getClass());//获取当前对象是哪一个类
// service1.setCorePoolSize(15);
// service1.setKeepAliveTime();
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合使用于Runnable，这里就帮忙执行run()了
service.execute(new NumberThread1());
// service.submit(Callable callable);//适合使用于Callable，有返回值，用FutureTask接收一下就行
//3.关闭线程池
service.shutdown();
}
}
使用线程池的好处：
提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理
corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间后会终止
继承方式和实现方式的联系与区别
区别
继承Thread：线程代码存放在Thread子类run方法中
实现Runnable：线程代码存放在接口子类的run方法中
实现方式的好处
开发中：优先选择实现Runnable接口的方式
原因：
- 避免了单继承的局限性
- 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理来处理同一份资源
Runnable 和 Callable 有什么区别
- Runnable 接口 run 方法无返回值；Callable 接口 call 方法有返回值，支持泛型
- call()可以抛出异常，被外面的操作捕获，获取异常的信息，而run()不能抛出异常，只能在方法内try-catch处理异常
- 运行 Callable 任务可拿到一个 Future 对象，Future 表示异步计算的结果，它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过 Future 对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果
参考
https://www.bilibili.com/video/BV1Kb411W75N/?p=447&spm_id_from=pageDriver&vd_source=e3d2dcdad07ba1c727f3c9e7654f60b5
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
