Java-创建线程

Java-创建线程的三种方式

1.使用Thread

1.1创建一个没有任务执行的Thread

// 创建一个没有执行任务的线程
Thread thread = new Thread();
// start方法让线程开始执行
thread.start();

1.2创建一个有任务执行的Thread

// 创建一个有执行任务的线程，通过继承Thread的方式
Thread thread = new Thread() {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "  任务开始执行");
    }
};
thread.start();
​
// 创建一个有执行任务的线程，通过Runnable实现类的方式
// （注意，Thread其实也实现了Runnable接口，不过执行的是target的run()方法，本身没有执行逻辑，而target正是一个Runnable类型）
Thread thread1 = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "  任务开始执行");
    }
});
thread1.start();

1.3创建一个守护线程

守护线程的优先级较低，用于为系统中的其他线程或功能提供服务。如果一个JVM进程中只存在守护线程，那么该JVM进程就会退出。

// 创建一个线程，并设置为守护线程，守护线程的生命周期随jvm进程而消亡
Thread daemonThread = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 这行代码不一定会执行
        System.out.println(Thread.currentThread().getName() + "  守护线程执行");
    }
});
daemonThread.setDaemon(true);
daemonThread.start();
​
// 让主线程暂停0.5s
try {
    Thread.sleep(500);
} catch (Exception e) {
    e.printStackTrace();
}

2.使用Runnable

Runnable的实现类可以作为Thread要执行的对应的实例。

// 创建一个类，并实现Runnable的run()方法
public class IRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 执行");
    }
}
// 创建一个线程，执行IRunnable的run()方法
Thread thread = new Thread(new IRunnable());
thread.start();

注意：Runnable没有返回值。

3.使用Callable

Callable+Future可以作为Thread要执行的对应的实例。

public class ICallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " 执行");
        return 1;
    }
}
// Callable的实现类不能直接作为Thread执行的实例
Callable<Integer> callable = new ICallable();
// FutureTask实现了Runnable和Future，可以作为Thread执行的实例，且可以接受一个Callable实例
FutureTask<Integer> futureTask = new FutureTask<>(callable);
Thread thread = new Thread(futureTask);
thread.start();
try {
    Integer result = futureTask.get();
    System.out.println("Callable执行结果：" + result);
} catch (InterruptedException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    e.printStackTrace();
}

4.Runnable与Callable的区别

• Runnable没有返回值，Callable可以有返回值

• Runnable抛出的异常主线程无法捕获，Callable抛出的异常可以捕获

public class CallableException implements Callable {
    @Override
    public Object call() throws Exception {
        throw new RuntimeException("Callable异常");
    }
}
public class RunnableException implements Runnable {
    @Override
    public void run() {
        throw new RuntimeException("Runnable异常");
    }
}
Thread runnableException = new Thread(new RunnableException());
FutureTask futureTask = new FutureTask(new CallableException());
Thread callableException = new Thread(futureTask);
​
try {
    runnableException.start();
} catch (Exception e) {
    // 该行代码不会打印
    System.out.println("Runnable异常被捕获");
    e.printStackTrace();
}
​
try {
    callableException.start();
    futureTask.get();
} catch (Exception e) {
    // 该行代码会打印
    System.out.println("Callable异常被捕获");
    e.printStackTrace();
}