java实现线程的几种方式

java实现线程的几种方式

1. 继承Thread,重写run方法：
   创建自己的类Thread1,让它继承Thread,并重写run方法:

		public class Thread1 extends Thread {
			public void run() {
				for (int i = 0; i < 10; i++) {
					System.out.println("run:  " + i);
				}
			}
		}

重新创建一个测试类test，实例化自己创建的线程类，并调用start方法：

		public class test {
			public static void main(String[] args) {
				Thread1 th = new Thread1();
				th.start();
				for(int i = 0; i < 10; i++){
					System.out.println("------");
				}
			}
		}

2. 实现Runnable接口，重写run方法
创建自己的类Thread2,实现Runnable接口，重写run方法：

	public class Thread2 implements Runnable{
		@Override
		public void run() {
			for(int  i = 0; i < 10; i++){
				System.out.println("run:  "+i);
			}	
		}
	}

然后创建test测试类：实例化自己的类，并实例化Thread，并将对象作为参数传进Thread中，然后调用start方法：

	public static void main(String[] args) {
			/*
			Thread1 th = new Thread1();
			th.start();*/
		
			Thread2 t = new Thread2();
			Thread th = new Thread(t);
			th.start();
			for(int i = 0; i < 10; i++){
				System.out.println("------");
			}
		}

3. 实现Callable接口，重写call方法
Callable中的call方法是可以有返回值的，Callable中的泛型即为返回值的类型。
我们现在要用线程计算两个求和，第一个从1加到10，第二从1加到36，然后返回结果。
首先创建自己的类Thread3实现Callable接口，由于返回是整形，我们将泛型改为Integer,现在我们想将求和公式传递结束时的数值，这样以便我们实现求和，但是重写call方法是不允许传参的，于是我们可以用构造方法来解决：``

	public class Thread3 implements Callable<Integer> {
		private int a; 
		public Thread3(int a){
			this.a = a;
		}
		@Override
		public Integer call() throws Exception {
			int sum = 0;
			for(int i = 1; i <= a; i++){
				sum += i;
			}
			return sum;
		}
	}

这样当我们传入结束的数字就可以帮我们计算出来，现在创建测试类，先用Executor的newFixedThreadPool创建两个线程，返回是ExecutorService接口，接着我们调用接口的submit方法，最后我们需要拿到返回值，submit返回的是Futrure接口，然后调用get方法拿到返回结果，最后不要忘了关闭线程池：

	    ExecutorService es = Executors.newFixedThreadPool(2);
	    Future<Integer> f1 = es.submit(new Thread3(10));
	    Future<Integer> f2 = es.submit(new Thread3(36));
	    System.out.println(f1.get());
	    System.out.println(f2.get());
	    es.shutdown();