java线程详解一：线程的四种创建方式

java线程的四种创建方式

• 第一种方式继承Thread类

public class ExtendsThread extends Thread{

	@Override
    public void run() {
        System.out.println("开始运行线程的主方法run方法");
    }

    public static void main(String[] args) {
        ExtendsThread threadTest = new ExtendsThread();
        threadTest.start();// 必须调用start()方法才能启动线程
    }
}

• 第二种方式实现Runable接口

public class ImplRunable implements Runnable{
	@Override
	public void run() {
		System.out.println("开始运行线程的主方法run方法");
	}

	public static void main(String[] args) {
		ImplRunable implRunable = new ImplRunable();
		Thread t = new Thread(implRunable); 
		t.start();
	}
}

• 第三种方式实现Callable接口

public class ImplCallable implements Callable {
	@Override
	public String call(){
		System.out.println("开始运行线程的主方法run方法");
		return "运行结束":
	}

	public static void main(String[] args) {
		Callable<String> callable = new ImplCallable();
		FutureTask<String> futureTask = new FutureTask<>(callable);
		Thread t = new Thread(futureTask);
		t.start();
	}
} 

• 第四种方法使用线程池

public class ThreadPool{

	public static void main(String[] args) {
		new ThreadPool().newFixedThreadPool();
		new ThreadPool().newCachedThreadPool();
		new ThreadPool().newSingleThreadExecutor();
	}

	// 使用newFixedThreadPool创建线程池
	// 这种方法是创建固定线程数的线程池，如果使用线程的数量大于线程池里的线程数量，则需要等待其他线程释放，才可继续使用线程池里的线程
	public void newFixedThreadPool(){
		ExecutorService executorService = Executors.newFixedThreadPool(5);// 线程池里有5个线程
		for (int i = 0;i < 3;i++) {
			executorService.execute(new Runnable(){
				@Override
                public void run() {
                	System.out.println(Thread.currentThread().getName() + “线程开始执行”);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + “线程执行结束”);
                }
			});
		}
	}

	// 使用newCachedThreadPool创建线程池
	// 这种方法可不指定创建线程池的数量，会持续不断的产生线程，如果线程池里的线程60秒（默认时间）内没有被使用的话会自动销毁
	public void newCachedThreadPool(){
		ExecutorService executorService = Executors.newCachedThreadPool();
		for (int i = 0;i < 3;i++) {
			executorService.execute(new Runnable(){
				@Override
                public void run() {
                	System.out.println(Thread.currentThread().getName() + “线程开始执行”);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + “线程执行结束”);
                }
			});
		}
	}
	// 使用newSingleThreadExecutor创建线程池
	// 这种方法只有一个线程，必须等待此线程运行结束才可执行下一个任务
	public void newSingleThreadExecutor(){
		ExecutorService executorService = Executors.newSingleThreadExecutor();
		for (int i = 0;i < 3;i++) {
			executorService.execute(new Runnable(){
				@Override
                public void run() {
                	System.out.println(Thread.currentThread().getName() + “线程开始执行”);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + “线程执行结束”);
                }
			});
		}
	}
}