Java 并发老多事儿-使用线程

1 使用线程

有三种使用线程的方法：

1. 实现 Runnable 接口；
2. 实现 Callable 接口；
3. 继承 Thread 类。

实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class UseThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //需要实现 run() 方法。
        //通过 Thread 调用 start() 方法来启动线程。
        RunableDemo runableDemo = new RunableDemo();
        new Thread(runableDemo).start();

        //与 Runnable 相比，Callable 可以有返回值，
        // 返回值通过 FutureTask 进行封装。
        CallableDemo callableDemo = new CallableDemo();
        FutureTask<Integer> futureTask = new FutureTask<>(callableDemo);
        new Thread(futureTask).start();
        System.out.println("futureTask:"+futureTask.get());

        //同样也是需要实现 run() 方法，
        // 并且最后也是调用 start() 方法来启动线程。
        ThreadDemo threadDemo = new ThreadDemo();
        threadDemo.start();
    }
}

/**
 * 实现Runnable接口
 */
class RunableDemo implements Runnable{
    @Override
    public void run() {
        System.out.println("RunableDemo");
    }
}

/**
 * 实现Callable接口
 */
class CallableDemo implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("CallableDemo");
        return 10;
    }
}

/**
 * 继承Thread类
 */
class ThreadDemo extends Thread{
    @Override
    public void run() {
        super.run();
        System.out.println("ThreadDemo");
    }
}

2 实现接口 vs 继承 Thread

实现接口会更好一些，因为：

1. Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
2. 类可能只要求可执行即可，继承整个 Thread 类开销会过大。

3 Executor

Executor 管理多个异步任务的执行，而无需程序员显示地管理线程的生命周期。

主要有三种 Executor：

1. CachedTreadPool：一个任务创建一个线程；
2. FixedThreadPool：所有任务只能使用固定大小的线程；
3. SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。

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

public class ExecutorDemo {
    //一个任务创建一个线程
    private static ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
    //所有任务只能使用固定大小的线程
    private static ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
    //相当于大小为 1 的 FixedThreadPool
    private static ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

    public static void main(String[] args) {
        final Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().toString()+":T1");
            }
        },"T1");

        final Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().toString()+":T2");
            }
        },"T2");

        final Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().toString()+":T3");
            }
        },"T3");

        cachedThreadPool.submit(t1);
        cachedThreadPool.submit(t2);
        cachedThreadPool.submit(t3);
        cachedThreadPool.shutdown();

        fixedThreadPool.submit(t1);
        fixedThreadPool.submit(t2);
        fixedThreadPool.submit(t3);
        fixedThreadPool.shutdown();

//        singleThreadExecutor.submit(t1);
//        singleThreadExecutor.submit(t2);
//        singleThreadExecutor.submit(t3);
//        singleThreadExecutor.shutdown();

        singleThreadExecutor.execute(t1);
        singleThreadExecutor.execute(t2);
        singleThreadExecutor.execute(t3);
        singleThreadExecutor.shutdown();
    }
}

 

转载于:https://my.oschina.net/duhongming52java/blog/1647169