线程

1、进程与线程
概述：几乎任何的操作系统都支持运行多个任务，通常一个任务就是一个程序，而一个程序就是一个进程。当一个进程运行时，内部可能包括多个顺序执行流，每个顺序执行流就是一个线程。

进程：进程是指处于运行过程中的程序，并且具有一定的独立功能。进程是系统进行资源分配和调度的一个单位。当程序进入内存运行时，即为进程。

进程的特点：

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

2：动态性：进程和程序的区别在于进程是动态的，进程中有时间的概念，进程具有自己的生命周期和各种不同的状态。

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

并发性和并行性是不同的概念：并行是指同一时刻，多个命令在多个处理器上同时执行；并发是指在同一时刻，只有一条命令是在处理器上执行的，但多个进程命令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果

线程
线程是进程的组成部分，一个进程可以拥有多个线程，而一个线程必须拥有一个父进程。线程可以拥有自己的堆栈，自己的程序计数器和自己的局部变量，但不能拥有系统资源。它与父进程的其他线程共享该进程的所有资源。

线程的特点：

线程可以完成一定任务，可以和其它线程共享父进程的共享变量和部分环境，相互协作来完成任务。

线程是独立运行的，其不知道进程中是否还有其他线程存在。

线程的执行是抢占式的，也就是说，当前执行的线程随时可能被挂起，以便运行另一个线程。

一个线程可以创建或撤销另一个线程，一个进程中的多个线程可以并发执行。

2、线程的创建
创建方式一：通过实现类继承Thread接口，在实现类中重写Thread接口中的run方法来实现自己的任务，再通过实现类的对象调用start（）方法，来启动线程

创建方式二：通过实现类实现Runnable接口，再实现该接口中的run方法来实现自己的任务，将实现类对象作为target，使用Thread类进行线程的创建，再通过线程对象调用start方法来启动线程

创建方式三：JDK5开始，可以通过实现类实现Callable接口，再使用Future接口的实现类FutureTask包装Callable对象 ，将FutureTask作为创建Thread时的target创建并启动线程

三种创建方式代码如下：
测试类代码片：

	/*
	 * 开启线程的方式一：通过实现类继承Thread接口，重写Thread中的run()方法，
	 * 并在实现类中创建自己的任务,再通过该类的对象，调用父类的start()方法来开启线程
	 */
	MyThreadExtendsThread mt = new MyThreadExtendsThread();
	mt.start();
	
	/*
	 * 开启线程的方式二：通过实现类继承Runnable接口，再实现Runnable接口中的run()方法来
	 * 创建自己的任务，再通过Thread的构造方法public Thread(Runnable target),
	 * 将实现了Runnable接口的实现类对象作为参数进行Thread对象的构造，即可调用该Thread的
	 * 对象开启线程
	 */
	Thread t = new Thread(new MyThreadImplementsRunnable());
	t.start();
	
	/*
	 * 开启线程的方式三：通过实现类实现Callable接口，再使用FutureTask包装Callable对象
	 * 将FutureTask作为创建Thread时的target创建并启动线程
	 */
	MyThreadImplementsCallable mic = new MyThreadImplementsCallable();
	FutureTask<Integer> ft = new FutureTask<Integer>(mic);
	Thread t5 = new Thread(ft,"方式三线程");
	t5.start();

创建方式一的实现类：

public class MyThreadExtendsThread extends Thread {
	public void run() {
		for (int i = 0; i < 5; i++) {
			System.out.println("开启线程的方式一:子线程"+Thread.currentThread().getName()+i);
		}
	}
}

创建方式二的实现类：

public class MyThreadImplementsRunnable implements Runnable {

	public void run() {
		for (int i = 0; i < 5; i++) {
			System.out.println("通过实现Runnable接口开启线程，子线程："+Thread.currentThread().getName()+i);
		}
	}
}

创建方式三的实现类：

public class MyThreadImplementsCallable implements Callable<Integer> {

	public Integer call() throws Exception {
		System.out.println("线程的创建方式三：通过实现Callable接口");
		return new Integer(1);
	}

}

三种方式比较：
方式一：继承Thread类，编码方便，但多个线程无法共享实现类的实例变量

方式二：采用Runnable接口的方式创建多个线程可以共享线程类的实例变量，这是因为在这种方式下，程序创建的Runnable对象只是线程的target，而多个线程可以共享一个target，所以多个线程可以共享一个实例变量

方式三：同方式二，多个线程可以共享线程类的实例变量，而且Callable接口提供了一个call（）方法可以作为线程执行体，看起来和Runnable很像，但call（）方法更强大——call（）方法可以有返回值、call（）方法可以抛出异常

一般优先使用第二种方式

匿名内部类创建线程
除了这三种方式，可以用匿名内部类的方法来快速创建线程，方式一和方式二的匿名内部类创建线程实现代码如下：

/*
 * 通过匿名内部类结合方式开启线程
 */

//通过匿名内部类+继承Thread
Thread t1 = new Thread() {
	public void run() {
		System.out.println("通过匿名内部类+继承Tread开启线程");
	}
};
t1.start();

//通过匿名内部类+实现Runnable接口
Runnable r = new Runnable() {

	public void run() {
		// TODO Auto-generated method stub
		System.out.println("通过匿名内部类+实现Runnable接口开启线程");
	}
	
};
Thread t3 = new Thread(r);
t3.start();

3、线程名相关方法
Thread类的构造方法可以在创建对象时指明线程名，如Thread t =new Thread(“线程”);
如果不指明，则线程名字从0开始依此递增

Thread.currentThread().getName();//获取当前运行线程的名字
setName(String name);//设置线程名字

4、线程的安全问题
在Java中，线程的调度方式为抢占式调度（另外一种为分时调度），这导致了可能会出现一个线程在执行过程中进入阻塞状态，开启另外一个线程，当多个线程同时操作同一个数据的时候，可能会引发数据错乱等安全问题。

线程安全的三种解决方法：

方法一：通过对run()方法中可能引发问题的代码片段，用synchronized关键字进行加锁，加锁需要传递对象，该对象可以为任意对象。

方法二：通过对run()方法使用synchronized关键字进行加锁，此时加锁的对象为this关键字所指向的对象,当方法为静态方法时，锁定对象为方法所在的类.class。

方法三：通过使用Lock接口的实现类，调用lock()和unlock()方法，来对可能引发问题的代码片段进行加锁和解锁处理，Lock接口的实现类包括ReentrantLock ， ReentrantReadWriteLock.ReadLock ， ReentrantReadWriteLock.WriteLock ，这其中常用ReentrantLock类来对代码进行加锁解锁。

这三种解决方法的代码如下：

public class MyThreadSafeDisplayDemo implements Runnable {
	
	private int ticket = 100;
	private Object obj;
	public void run() {
		while(ticket>0) {
			System.out.println("Selling"+ticket+"张票");
			ticket --;
		}
	}
	
	/*
	 * 保证线程安全的方式一：对代码块使用synchronized关键字进行加锁，加锁需要传递对象，该对象
	 * 可以是任意对象
	 */
	public void run() {
		while(ticket>0) {
			synchronized(obj) {
				System.out.println("Selling"+ticket+"张票");
				ticket --;
			}
		}
	}
	
	/*
	 * 保证线程安全的方式二：对run方法使用synchronized关键字进行加锁，此时该锁锁定的对象为this
	 * 指向的对象,当方法为静态方法时，锁定对象为该为方法所在的类.class
	 */
	public synchronized void run() {
		while(ticket>0) {
				System.out.println("Selling"+ticket+"张票");
				ticket --;
		}
	}
	
	/*
	 * 保证线程安全的方式三：使用Lock接口的实现类，来调用lock（）方法和unlock()方法，
	 * 对线程进行加锁解锁即可
	 * 
	 */
	public synchronized void run() {
		while(ticket>0) {
			Lock l = new ReentrantLock();
			l.lock();
			System.out.println("Selling"+ticket+"张票");
			ticket --;
			l.unlock();
		}
	}
}

5、线程的状态

对于同一个线程，如果多次启动，会引发IllegalThreadStateException异常。

线程可能处于的状态包括：
新建：NEW
运行：RUNNABLE
阻塞：BLOCKED
等待：WAITING
休眠：TIMED_WAITING
终止（消亡）：TERMINATED

API描述如下：

线程状态之间的切换描述图如下：