第2章 Java并行程序基础

2.2 初始线程：线程的基本操作

2.2.1 新建线程

新建线程方式一：

Thread thread = new Thread();
thread.start();

　　但要注意！如果像下面用run()来启动新线程，它只会在当前线程中，串行执行run()中的代码。

Thread thread2 = new Thread();
thread2.run();

新建线程方式二：

　　默认情况下，Thread的run()方法什么都没有过做，线程地启动就马上结束了。如果要让线程做点什么，就要重载run()方法，把你的"任务"填进去。　　

Thread thread3 = new Thread(){//(匿名内部类)
	@Override
	public void run() {
		//super.run();
		System.out.println("Hello,I am t3");
	}
};
thread3.start();

新建线程方式三：

　　如果没有特别的需要，都可以通过继承Thread，重载run()方法来自定义线程。（方式三完整代码：点击Github打开链接）

public class SocketThread extends Thread {
	public SocketThread(Socket socket) {
		//...
		start();
	}
	public void run() {
	//super.run();
	//...
}}

public class SocketServer {
	public static final int PORT = 50000;
	public static void main(String[] args) throws IOException {
		ServerSocket s = new ServerSocket(PORT);
		System.out.println("开始: " + s);
		while(true) {
			Socket socket = s.accept();
			new SocketThread(socket);//匿名方法
		}
	}
}

新建线程方式四：

　　因为Java是单继续的，也就是说继续本身也是一各很宝贵的资源，因此我们也可以使用Runable接口来实现同样的操作。Runable接口是一个单方法接口，它只有一个run()方法：

public interface Runnable {
	public abstract void run();
}

　　此外,Thread类有一个非常重要的构造方法，它传入一个Runable接口的实例，在start()方法调用时，新的线程就会执行Runable接口的run()方法。实现上，Thread类默认的run()就是这么做的：

public class Thread implements Runnable {
	public Thread(Runnable target) {
		init(null, target, "Thread-" + nextThreadNum(), 0);
	}
	private Runnable target;
	@Override
	public void run() {
		if (target != null) {
			target.run();
		}
	}
}

　　这种方式实现了Runable接口，并将该实例传入Thread。这样避免重载Thread类的run()方法，单纯使用接口来定义Thread，也是最常用的做法：

public class CreateThread_WithInterface implements Runnable {
	public static void main(String[] args) {
		Thread thread = new Thread(new CreateThread_WithInterface());
		thread.start();
	}
	@Override
	public void run() {
		System.out.println("Oh, I am Runable");
	}
}

　　下面是新建线程方式四的变种，这样代码更简洁：

public class CreateThread_WithInterface2 {
	public static void main(String[] args) {
		Thread thread = new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("I am Implemented...");
			}
		});
		thread.start();
	}
}

　　也可以这样变种（点击打开Github链接）：

public class CreateThread_WithInterface_Lock {
	// http://www.cnblogs.com/benshan/p/3551987.html
	public static void main(String[] args) {
		Lock lock = new ReentrantLock();
		Consumer consumer = new Consumer(lock);
		Producer producer = new Producer(lock);
		new Thread(consumer).start();
		new Thread(producer).start();
	}
}

public class Producer implements Runnable {
	private Lock lock;
	public Producer(Lock lock) {
		this.lock = lock;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
	}
}

附完整代码：点击打开Github链接

本书 第1章走入并行世界 视频：点击打开链接

**Wu_Being博客声明**：本人博客欢迎转载，请标明博客原文和原链接！谢谢！《Java线程的创建》：http://blog.csdn.net/u014134180/article/details/51243721

如果你看完这篇博文，觉得对你有帮助，并且愿意付赞助费，那么我会更有动力写下去。