进程、线程、线程的创建及多线程

1.进程(Process)

所有运行中的任务都对应一条进程。当一个程序进入内存运行，就变成了一个进程。进程是处于运行过程中的程序，并且具有一定独立功能。进程是系统进行资源分配和调度的一个独立单位。

进程有三个特征：

1）独立性：进程是系统中独立存在的实体，它可以拥有自己独立的资源，每一个进程都拥有自己私有的地址空间。在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空间。

2）动态性：进程是一个正在系统中活动的指令集合。

3）并发性：多个进程可以在单个处理器上并发执行，多个进程之间不会互相影响。

注：并行性和并发性

并行：在同一时刻，有多条指令在多个处理器上同时执行。

并发：同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果。

2.线程(Thread)

线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程，线程是进程的执行单元。线程不再拥有系统资源，它与父进程的其他线程共享该进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。

多线程存在于一个应用程序中，让一个应用程序中可以有多个执行部分同时执行，但操作系统无须将多个线程看作多个独立的应用，对多线程实现调度和管理以及资源分配。线程的调度和管理由进程本身负责完成。

一个程序运行至少有一个进程，一个进程里可以包含多个线程，但至少要包含一个线程。

3.多线程的优势

*进程间不能共享内存，而线程之间共享内存非常容易。因为多个线程共享同一个进程虚拟空间，利用这些共享数据，线程间互相通信很容易。

*系统创建进程需要为该进程重新分配系统资源，而创建线程代价小得多，因此使用多线程来实现多任务并发比多进程的效率高。

4.线程的状态

5.线程的创建

1）继承Thread类创建线程类

a.定义Thread类的子类，并重写该类的run()方法。

b.创建Thread子类的对象。

c.用线程对象的start()方法来启动线程。

例1：

 

package com.itheima;

/**
 * 继承Thread类创建线程类
 * */

public class ThreadDemo_1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//创建两个线程
		FirstThread t1 = new FirstThread();
		FirstThread t2 = new FirstThread();
		//开启两个线程
		t1.start();
		t2.start();
		
		//主线程执行的代码
		for(int i = 0; i < 60; i++) {
			//调用Thread的currentThread方法获取当前线程
			System.out.println(Thread.currentThread().getName() + "---" + i);
		}

	}	
}


class FirstThread extends Thread {
	
	//重写run方法，封装线程要执行的代码
	public void run() {
		for(int i = 0; i < 60; i++) {
			//getName()返回当前线程的名字
			System.out.println(getName() + "---" + i);
		}
	}
}

2）实现Runnable接口创建线程类

 

a.定义Runnable接口实现类，重写run()方法。

b.创建Runnable实现类对象，并将该对象作为参数传入Thread类的构造器来创建Thread对象。

c.调用Thread对象的start()方法。

例2：

 

package com.itheima;

/**
 * 实现Runnable接口创建线程类
 * */

public class ThreadDemo_2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//开启两个线程
		new Thread(new SecondThread()).start();
		new Thread(new SecondThread()).start();
		
		//主线程执行的代码
		for(int i = 0; i < 60; i++) {
			//调用Thread的currentThread方法获取当前线程
			System.out.println(Thread.currentThread().getName() + "---" + i);
		}
	}
}

class SecondThread implements Runnable {
	//重写run方法，封装线程要执行的代码
		public void run() {
			for(int i = 0; i < 60; i++) {
				//当线程类实现Runnable接口时，
				//如果想获取当前线程，只能用Thread.currentThread()方法。
				System.out.println(Thread.currentThread().getName() + "---" + i);
			}
		}
}

6.两种方式比较

 

1）采用实现Runnable接口方式：

优势：线程类只是实现了Runnable接口，还可以继承其他类；多个线程可以共享线程类的实例属性，因为是多条线程访问同一个Runnable  实现类对象。

劣势：如果要访问当前线程，必须使用Thread.currentThread()方法。

2）采用继承Thread类方式：

优势：编写简单，如果访问当前线程，无需使用Thread.currentThread()方法，直接使用this即可。

劣势：因为线程类已经继承了Thread类，所以不能再继承其他父类；多条线程无法共享线程类的实例变量。

 

7.注意

1）不要对已经处于启动状态的线程再次调用start方法，否则将引发IllegalThreadStateException异常。

2）不要对处于死亡状态的线程调用start方法，程序只能对新建状态的线程调用start方法。否则将引发IllegalThreadStateException异常。

3）当主线程结束的时候，其他线程不受任何影响，并不会随之结束。一旦子线程启动起来，它就拥有和主线程相同的地位，它不受主线程的影响。