#线程的创建方式
一.通过继承Thread创建
1.创建一个类继承 Thread 类,并重写 run() 方法。
2.在 run() 方法中编写线程执行的代码。
3.实例化这个新类,并调用 start() 方法来启动线程
package com.ktjy.test;
/**
* MyThread 类继承了 Thread 类,用于演示如何创建并运行一个简单的多线程程序
*/
class MyThread extends Thread {
@Override
public void run() {
// 当线程启动后,将打印出线程的名称,以示区分
System.out.println("你好,我是多线程 " + this.getName());
}
}
/**
* Main 类包含 main 方法,用于启动一个 MyThread 线程实例
*/
public class Main {
public static void main(String[] args) {
// 创建一个 MyThread 线程实例
MyThread thread = new MyThread();
// 启动线程,使其开始执行 run 方法中的代码
thread.start();
}
}
二.通过实现Runnable
package com.ktjy.test;
/**
* 实现Runnable接口的自定义类,用于创建不可返回结果的多线程任务。
*/
class MyRunnable implements Runnable {
/**
* 当这个线程被调用时,将会执行这个方法。
*/
@Override
public void run() {
System.out.println("你好,我是多线程 " + Thread.currentThread().getName());
}
}
/**
* 主类,用于演示如何使用自定义的Runnable类创建并执行多线程任务。
*/
public class Main {
/**
* 程序的入口点。
*
* @param args 命令行参数,本示例中未使用。
*/
public static void main(String[] args) {
// 创建一个MyRunnable对象,作为多线程任务。
Runnable runnable = new MyRunnable();
// 启动一个新的线程来执行runnable。
new Thread(runnable).start();
}
}
三.通过实现Callable
package com.ktjy.test;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
/**
* 实现Callable接口的自定义类,用于创建可返回结果的多线程任务。
*/
class MyCallable implements Callable<String> {
/**
* 当这个线程被调用时,将会执行这个方法。
*
* @return 返回一个包含当前线程名称的字符串,用来标识不同的线程。
* @throws Exception 如果在执行过程中发生错误,可以抛出异常。
*/
@Override
public String call() throws Exception {
return "你好,我是多线程 " + Thread.currentThread().getName();
}
}
/**
* 主类,用于演示如何使用自定义的Callable类创建并执行多线程任务。
*/
public class Main {
/**
* 程序的入口点。
*
* @param args 命令行参数,本示例中未使用。
*/
public static void main(String[] args) {
// 创建一个MyCallable对象,作为多线程任务。
Callable<String> callable = new MyCallable();
// 使用FutureTask包装Callable对象,以便能够获取线程的执行结果。
FutureTask<String> futureTask = new FutureTask<>(callable);
// 启动一个新的线程来执行futureTask。
new Thread(futureTask).start();
try {
// 获取futureTask的执行结果,并打印出来。
System.out.println(futureTask.get());
} catch (Exception e) {
// 处理可能发生的异常。
e.printStackTrace();
}
}
}
#四种线程池
1.newCachedThreadPool - 创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
2.newFixedThreadPool - 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。
3.newScheduledThreadPool - 创建一个定长线程池,支持定时及周期性任务执行。
4.newSingleThreadExecutor - 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序执行。
这个Java程序演示了如何使用自定义的Runnable类创建并执行多线程任务。程序首先定义了一个实现Runnable接口的自定义类MyRunnable,其中的run方法包含了线程执行的逻辑。然后,在Main类的main方法中,创建了一个MyRunnable对象,并使用四种不同类型的线程池(CachedThreadPool、FixedThreadPool、ScheduledThreadPool和SingleThreadExecutor)来执行这个任务。最后,程序关闭线程池,并等待所有任务完成,然后输出线程池的状态。
package com.ktjy.test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
* 实现Runnable接口的自定义类,用于创建不可返回结果的多线程任务。
*/
class MyRunnable implements Runnable {
/**
* 当这个线程被调用时,将会执行这个方法。
*/
@Override
public void run() {
System.out.println("你好,我是多线程 " + Thread.currentThread().getName());
}
}
/**
* 主类,用于演示如何使用自定义的Runnable类创建并执行多线程任务。
*/
public class Main {
/**
* 程序的入口点。
*
* @param args 命令行参数,本示例中未使用。
*/
public static void main(String[] args) {
// 创建一个MyRunnable对象,作为多线程任务。
Runnable runnable = new MyRunnable();
// 使用四种不同类型的线程池来执行任务
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
// 提交任务到线程池
cachedThreadPool.execute(runnable);
fixedThreadPool.execute(runnable);
scheduledThreadPool.execute(runnable);
singleThreadExecutor.execute(runnable);
// 关闭线程池
cachedThreadPool.shutdown();
fixedThreadPool.shutdown();
scheduledThreadPool.shutdown();
singleThreadExecutor.shutdown();
// 等待所有任务完成
while (!cachedThreadPool.isTerminated()) ;
while (!fixedThreadPool.isTerminated()) ;
while (!scheduledThreadPool.isTerminated()) ;
while (!singleThreadExecutor.isTerminated()) ;
// 输出线程池状态
System.out.println("CachedThreadPool terminated: " + cachedThreadPool.isTerminated());
System.out.println("FixedThreadPool terminated: " + fixedThreadPool.isTerminated());
System.out.println("ScheduledThreadPool terminated: " + scheduledThreadPool.isTerminated());
System.out.println("SingleThreadExecutor terminated: " + singleThreadExecutor.isTerminated());
}
}