java多线程

程序与进程：

程序是一个静态的概念，是一组有序的静态指令。  而进程则是执行程序的动态过程。

一个程序可以执行多个进程，一个进程可以执行多个程序。例如：一个进程进行C源程序编译时，它要执行前处理、词法语法分析、代码生成等几个程序。反之，同一个程序也可能由多个进程同时执行。

程序可以作为一种软件资源长期保存着；而进程则只是在执行时存在，它是暂时的。

进程需要使用一种机制才能执行程序，这种机构成为处理机（Processor）。处理机执行指令，根据指令的性质，处理机可以单独用硬件或者软、硬件结合起来构成。如果指令是机器指令，那么处理机就是CPU。

进程具有并发与不确定性。

线程与进程：

进程具备并发的特点，这种并发性是不同进程之间反映出来的，不同的进程有不同进程空间，进程之间的切换消耗比较大。于是，引进了线程的概念。在进程的内部引入并发性，一个进程可以创建多个线程。不同线程之间共享进程的地址空间和数据。

一般地讲，线程是一个程序，或者进程内部的一个顺序控制流。线程本身不能独立运行，必须在进程中执行，使用进程的地址空间。每个线程有自己单独的程序计数器。

每个程序执行时都会产生一个进程，而每一个进程至少产生一个主线程。

创建线程：

java定义了一个线程的概念模型，把一个线程分为了三部分：虚拟CPU（java .lang.Thread类），虚拟CPU执行代码和数据。创建一个java .lang.Thread的对像，就意味着创建一个线程。  一个由main开始执行的java程序，至少包含一个线程（主线程）。创建多个Thread对象，就创建了多个线程。

Thread类通过其run（）方法来执行任务，方法run（）为线程体。一般在java中有两种比较典型的构造线程的方法：

1）继承Thread类，重写run（）方法。

2）实现Runnable接口，重写run（）方法。

这两种方法都通过Thread类的start（）方法启动线程。

 

 

public class TestThread1 extends Thread{
	public TestThread1(String name) {
		super(name);
		
	}
	@Override
	public void run() {
		for(int i=0; i<10; i++) {	
			System.out.println(Thread.currentThread().getName() + "------" + i);
		}
	}
	public static void main(String args[]) {
		TestThread1 testThread1 = new TestThread1("subThread");
		testThread1.start();
		for(int i=0; i<10; i++) {
			System.out.println(Thread.currentThread().getName() + "------" + i);
		}
		
	}
}
/*out:
	main------0
	main------1
	main------2
	main------3
	main------4
	main------5
	main------6
	subThread------0
	subThread------1
	subThread------2
	subThread------3
	subThread------4
	subThread------5
	subThread------6
	main------7
	main------8
	main------9
	subThread------7
	subThread------8
	subThread------9
*/

 

这种创建方式，把线程执行的逻辑代码直接写在Thread的子类中。根据线程的概念的模型，虚拟CPU与代码就混合在一起，这样不便于以后的维和和扩展。

下面实例演示虚拟CPU与代码分离：

public class TestThread0 {
	public static void main(String args[]) {
		MyThreadDemo myThread = new MyThreadDemo();
		myThread.start();
		for(int i=0; i<10; i++) {
			System.out.println(Thread.currentThread().getName() + "------" + i);
		}
	}
}
class MyThreadDemo extends Thread {
	public void run() {
		for(int i=0; i<10; i++) {	
			System.out.println(Thread.currentThread().getName() + "------" + i);
		}
	}
}
/*out:
	main------0
	main------1
	main------2
	main------3
	main------4
	main------5
	Thread-0------0
	main------6
	main------7
	main------8
	main------9
	Thread-0------1
	Thread-0------2
	Thread-0------3
	Thread-0------4
	Thread-0------5
	Thread-0------6
	Thread-0------7
	Thread-0------8
	Thread-0------9
*/

 

java是单继承的，子类继承自Thread之后就不能继承其他父类了，这样影响了其扩展性。

下面示例演示实现Runnable接口：

 

public class CopyOfTestThread0 {
	public static void main(String args[]) {
		RunnerDemo r = new RunnerDemo();
		r.run();
		Thread t = new Thread(r,"subThread");
		t.start();
		for(int i=0; i<10; i++) {
			System.out.println(Thread.currentThread().getName() + "------" + i);
		}
	}
}
class RunnerDemo implements Runnable {
	public void run() {
		for(int i=0; i<10; i++) {	
			System.out.println(Thread.currentThread().getName() + "------" + i);
		}
	}
}
/*out:
	main------0
	main------1
	main------2
	main------3
	main------4
	main------5
	main------6
	main------7
	main------8
	main------9
	main------0
	main------1
	main------2
	main------3
	main------4
	main------5
	main------6
	main------7
	main------8
	main------9
	subThread------0
	subThread------1
	subThread------2
	subThread------3
	subThread------4
	subThread------5
	subThread------6
	subThread------7
	subThread------8
	subThread------9*/

 

每个线程都占用一些CPU时间以及内存空间，如果创建过多，就将消耗过大，使得整个进程运行缓慢。java使用线程池应对这个问题。