创建线程的几种方法

一. 创建线程的方法：

1. 继承Thread类创建线程

这是最基本的创建线程的方式，我们可以通过继承Thread类来创建一个自定义的线程类，然后重写run()方法，实现线程的逻辑。

public class MyThread extends Thread {
 @Override
 public void run() {
 // 线程逻辑
 }
}

// 创建并启动线程
MyThread myThread = new MyThread();
myThread.start();

2. 实现Runnable接口创建线程

这是另一种常见的创建线程的方式，我们可以通过实现Runnable接口来创建一个自定义的线程类，然后将该类实例化并传递给Thread类的构造方法中，最后调用start()方法启动线程。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程逻辑
    }
}

// 创建并启动线程
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

3. 实现Callable接口创建线程

Callable接口与Runnable接口类似，但是它可以返回一个结果并抛出异常。我们可以通过实现Callable接口来创建一个自定义的线程类，然后将该类实例化并传递给FutureTask类的构造方法中，最后调用start()方法启动线程。

public class MyCallable implements Callable {
    @Override
    public String call() throws Exception {
        // 线程逻辑
        return "result";
    }
}

// 创建并启动线程
MyCallable myCallable = new MyCallable();
FutureTask futureTask = new FutureTask<>(myCallable);
Thread thread = new Thread(futureTask);
thread.start();

// 获取线程返回结果
String result = futureTask.get();

4. 使用线程池创建线程

线程池是一种重用线程的机制，可以减少线程创建和销毁的开销。我们可以通过Executors类提供的静态方法来创建不同类型的线程池，然后将任务提交给线程池执行。

ExecutorService executorService = Executors.newFixedThreadPool(10);

// 提交任务并执行
executorService.submit(new Runnable() {
    @Override
    public void run() {
        // 线程逻辑
    }
});

// 关闭线程池
executorService.shutdown();

5. 使用定时器创建线程

定时器可以用来定时执行某个任务。我们可以通过Timer类来创建一个定时器，然后将任务添加到定时器中执行。

TimerTask timerTask = new TimerTask() {
    @Override
    public void run() {
        // 线程逻辑
    }
};

// 创建定时器并执行任务
Timer timer = new Timer();
timer.schedule(timerTask, new Date(), 1000);

// 关闭定时器
timer.cancel();

6. 使用ScheduledExecutorService创建线程

ScheduledExecutorService是一种可以调度任务执行的线程池。我们可以通过它来创建一个定时任务，也可以创建一个周期性任务。

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);

// 创建定时任务并执行
scheduledExecutorService.schedule(new Runnable() {
    @Override
    public void run() {
        // 线程逻辑
    }
}, 1, TimeUnit.SECONDS);

// 创建周期性任务并执行
scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        // 线程逻辑
    }
}, 1, 1, TimeUnit.SECONDS);

// 关闭线程池
scheduledExecutorService.shutdown();

7. 使用Fork/Join框架创建线程

Fork/Join框架是Java 7中引入的一种并行执行任务的机制。它可以将一个大任务拆分成多个小任务并行执行，最后将结果合并。

public class MyTask extends RecursiveTask {
    private int start;
    private int end;

    public MyTask(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        if (end - start <= 1000) {
            // 执行小任务
            return 0;
        } else {
            // 拆分大任务
            int mid = (start + end) / 2;
            MyTask leftTask = new MyTask(start, mid);
            MyTask rightTask = new MyTask(mid + 1, end);
            leftTask.fork();
            rightTask.fork();

            // 合并结果
            return leftTask.join() + rightTask.join();
        }
    }
}

// 创建并执行任务
ForkJoinPool forkJoinPool = new ForkJoinPool();
MyTask myTask = new MyTask(1, 10000);
int result = forkJoinPool.invoke(myTask);

8. 使用Semaphore创建线程

Semaphore是一种计数器，用来控制同时访问某个资源的线程数量。我们可以通过Semaphore来创建一个有限的线程池。

Semaphore semaphore = new Semaphore(10);

// 创建并执行任务
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        try {
            semaphore.acquire();
            // 线程逻辑
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
};

for (int i = 0; i < 100; i++) {
    new Thread(runnable).start();
}

创建多个线程来同时执行多个任务的简单的代码案例，示例如下：

public class MyThread implements Runnable {
    private String taskName;

    public MyThread(String taskName) {
        this.taskName = taskName;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(taskName + "执行了第" + (i + 1) + "次任务");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        MyThread thread1 = new MyThread("线程1");
        MyThread thread2 = new MyThread("线程2");
        Thread t1 = new Thread(thread1);
        Thread t2 = new Thread(thread2);
        t1.start();
        t2.start();
    }
}