Java创建线程的几种方式

在Java中，线程是一种轻量级的执行单元，可以同时执行多个任务。创建线程是Java多线程编程的基本操作之一，本文将介绍Java中创建线程的几种方式，并提供示例代码和测试用例。

1. 继承Thread类

Java中最常见的创建线程的方式是继承Thread类。具体步骤如下：

1. 创建一个继承自Thread类的子类，重写子类的run()方法，该方法中定义线程要执行的任务。
2. 创建Thread类的实例对象。
3. 调用start()方法启动线程。

下面是一个示例代码：

public class MyThread extends Thread { 
    @Override
    public void run() { 
        System.out.println("Thread is running");
    }
}

public class Main { 
    public static void main(String[] args) { 
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

在上述示例中，创建了一个继承自Thread类的子类MyThread，重写了run()方法，并在main()方法中创建了MyThread的实例对象myThread，然后调用start()方法启动线程。

测试用例：

@Test
public void testThread() { 
    MyThread myThread = new MyThread();
    myThread.start();

    // 等待线程执行完毕
    try { 
        myThread.join();
    } catch (InterruptedException e) { 
        e.printStackTrace();
    }

    // 断言输出是否正确
    assertEquals("Thread is running", outContent.toString().trim());
}

2. 实现Runnable接口

除了继承Thread类外，Java中还可以通过实现Runnable接口来创建线程。具体步骤如下：

1. 创建一个实现Runnable接口的类，该类中实现run()方法。
2. 创建Thread类的实例对象，并将Runnable接口的实现类对象作为参数传递给Thread类的构造方法。
3. 调用start()方法启动线程。

下面是一个示例代码：

public class MyRunnable implements Runnable { 
    @Override
    public void run() { 
        System.out.println("Thread is running");
    }
}

public class Main { 
    public static void main(String[] args) { 
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

在上述示例中，创建了一个实现Runnable接口的类MyRunnable，重写了run()方法，并在main()方法中创建了MyRunnable的实例对象myRunnable，然后用myRunnable创建了Thread类的实例对象thread，最后调用start()方法启动线程。

测试用例：

@Test
public void testRunnable() { 
    MyRunnable myRunnable = new MyRunnable();
    Thread thread = new Thread(myRunnable);
    thread.start();

    // 等待线程执行完毕
    try { 
        thread.join();
    } catch (InterruptedException e) { 
        e.printStackTrace();
    }

    // 断言输出是否正确
    assertEquals("Thread is running", outContent.toString().trim());
}

3. 使用Callable和Future

除了继承Thread类和实现Runnable接口外，Java 5引入了Callable和Future接口，可以实现带有返回值的线程。具体步骤如下：

1. 创建一个实现Callable接口的类，该类中实现call()方法，并指定返回值的类型。
2. 创建ExecutorService线程池对象。
3. 使用ExecutorService的submit()方法提交Callable对象，并返回一个Future对象。
4. 调用Future对象的get()方法获取线程的返回值。

下面是一个示例代码：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class MyCallable implements Callable<String> { 
    @Override
    public String call() { 
        return "Thread is running";
    }
}

public class Main { 
    public static void main(String[] args) throws Exception { 
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Callable<String> callable = new MyCallable();
        Future<String> future = executorService.submit(callable);
        String result = future.get();
        System.out.println(result);
        executorService.shutdown();
    }
}

在上述示例中，创建了一个实现Callable接口的类MyCallable，重写了call()方法，并在main()方法中创建了一个ExecutorService线程池对象executorService，用于执行Callable对象。通过executorService.submit(callable)提交Callable对象，并返回一个Future对象，在调用future.get()方法获取线程的返回值。

测试用例：

@Test
public void testCallable() throws Exception { 
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    Callable<String> callable = new MyCallable();
    Future<String> future = executorService.submit(callable);
    String result = future.get();
    executorService.shutdown();

    // 断言输出是否正确
    assertEquals("Thread is running", result);
}

4. 使用线程池

在实际开发中，经常使用线程池来管理和复用线程。Java提供了Executors类来创建不同类型的线程池。具体步骤如下：

1. 使用Executors类的静态方法创建一个指定类型的线程池。
2. 创建Runnable或Callable对象，用于表示线程要执行的任务。
3. 使用线程池的submit()方法提交Runnable或Callable对象。

下面是一个示例代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyRunnable implements Runnable { 
    @Override
    public void run() { 
        System.out.println("Thread is running");
    }
}

public class Main { 
    public static void main(String[] args) { 
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        Runnable runnable = new MyRunnable();
        executorService.submit(runnable);
        executorService.shutdown();
    }
}

在上述示例中，使用Executors.newFixedThreadPool(5)创建了一个固定大小为5的线程池，然后创建了一个Runnable对象runnable表示线程要执行的任务，最后通过executorService.submit(runnable)提交任务给线程池执行。

测试用例：

@Test
public void testThreadPool() { 
    ExecutorService executorService = Executors.newFixedThreadPool(5);
    Runnable runnable = new MyRunnable();
    executorService.submit(runnable);
    executorService.shutdown();
    // 等待线程池中的任务执行完毕
    try { 
        executorService.awaitTermination(1, TimeUnit.SECONDS);
    } catch (InterruptedException e) { 
        e.printStackTrace();
    }
    // 断言输出是否正确
    assertEquals("Thread is running", outContent.toString().trim());
}

结论

本文介绍了Java中创建线程的几种方式，包括继承Thread类、实现Runnable接口、使用Callable和Future、以及使用线程池。每种方式都提供了示例代码和测试用例，加强了博客内容的阐述。

通过继承Thread类和实现Runnable接口创建线程是最常见的方式，而使用Callable和Future可以获得线程的返回值。使用线程池可以更好地管理和复用线程，提高程序的性能和效率。