Java多线程

Java多线程

进程和线程基本概念

进程–概念

进程是指运行中的应用程序，每个进程都有自己独立的地址空间(内存空间)，比如用户打开一个软件，这就相当于启动了一个进程，操作系统就会为该进程分配独立的地址空间。当用户打开另一个软件，相当于又启动了一个进程，操作系统将为新的进程分配新的独立的地址空间。目前操作系统都支持多进程。

要点：用户每启动一个进程，操作系统就会为该进程分配一个独立的内存空间。

线程–概念

线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。线程有就绪、阻塞和运行三种基本状态。

线程

1、线程是轻量级的进程

2、线程没有独立的地址空间(内存空间)

3、线程是由进程创建的(寄生在进程)

4、一个进程可以拥有多个线程–>这就是我们常说的多线程编程

5、线程有几种状态：

a、新建状态(new)

b、就绪状态(Runnable)

c、运行状态(Running)

d、阻塞状态(Blocked)

e、死亡状态(Dead)

线程的用处

解决了并发问题，也就是说当对象需要同时运行时，就可以用多线程技术。

线程–如何使用

在java中一个类要当作线程来使用有两种方法。

1、继承Thread类，并重写run函数

2、实现Runnable接口，并重写run函数

因为java是单继承的,在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然不可能，java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程。

通过继承Thread类和实现Runnable接口来实现建立线程

/**
 * 继承Thread类实现线程
 * 或者实现Runnable接口
 */
package com.thread;

public class Thread1 {

	public static void main(String[] args) {

		// 创建对象
		Cat cat  =  new Cat();

		// 启动线程,调用run()方法
		cat.start();

Dog dog = new Dog();
		//创建线程
		Thread t = new Thread(dog);
		//启动线程
		t.start();

	}

}

class Cat extends Thread{
	// 记数
	int times  =  0;

	public void run() {
		// 休眠一秒
		// 1000毫秒 = 1秒
		// sleep()进入Block状态，并释放资源
		while (true) {
			try {
				Thread.sleep(1000);

			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			times++;
			System.out.println("hello,world " + times);
			if (times  ==  10) {
				break;
			}
		}
	}
}

// 创建Runnable接口
class Dog implements Runnable {
	int times  =  0;

	// 重写run函数
	public void run() {
// 休眠一秒
		// 1000毫秒 = 1秒
// sleep()进入Block状态，并释放资源
		while (true) {
			try {
				Thread.sleep(1000);
			} catch (Exception e) {
				e.printStackTrace();
			}
			times++;
			System.out.println("hello,wrold!" + times);
			if (times  ==  10) {
				break;
			}
		}
	}
}




/**
 * 两个线程同时运行的案例
 */
package com.thread;

public class Thread2 {

	
	public static void main(String[] args) {
		Pig pig = new Pig(10);
		Bird bird = new Bird(10);
		//创建线程
		Thread t1 = new Thread(pig);
		Thread t2 = new Thread(bird);
		//启动线程
		t1.start();
		t2.start();
	}

}

//累加
class Bird implements Runnable{
	int n = 0;
	int times = 0;
	int sum = 0;
	public Bird(int n){
		this.n = n;
	}
	public void run(){
		while(true){
			try {
				Thread.sleep(1000);
			} catch (Exception e) {
				e.printStackTrace();
			}
			sum += (++times);
			System.out.println("当前结果是：" + sum);
			if(times == n){
				System.out.println("最后结果是：" + sum);
				break;
			}
		}
	}
}
//打印
class Pig implements Runnable{
	
	int n = 0;
	int times = 0;
	public Pig(int n){
		this.n = n;
	}
	public void run(){
		while(true){
			try {
				Thread.sleep(1000);
			} catch (Exception e) {
				e.printStackTrace();
			}
			times++;
			System.out.println("线程输出 " + times);
			if(times == n){
				break;
			}
		}
	}
}

线程–继承Thread和实现Runnable的区别

从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口，如果一定要说它们有什么区别，有如下几点：

1、尽可能使用实现Runnable接口的方式来创建线程

2、在使用Thread的时候只需要new一个实例出来，调用start()方法即可以启动一个线程，如：

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

3、在使用Runnable的时候需要先new一个实现Runnable的实例，之后用Thread调用，如:

Test t=new Test();//Test实现了Runnable接口
Thread test=new Thread(t);
tset.start();

用实现Runnable接口的特点

1、用实现Runnable接口的方法创建对象可以避免java单继承机制带来的局限；

2、用实现Runnable接口的方法，可以实现多个线程共享同一段代码(数据)；

因此如果程序有同步逻辑需求，则使用Runnable的方法来创建线程。

线程–深入理解

不管是通过继承Thread，还是通过实现Runnable接口创建线程，它们的一个对象只能启动(即：start())一次。否则就会有异常抛出。

java线程的同步

线程同步机制–介绍

多线程编程为我们处理同时并发的事务提供了很好的帮助，但是由此而来却引发一个严重的问题，那就是线程的安全问题。

而解决这个问题的关键，是保证事务的原子性(线程1开始执行某段原子代码，线程2要执行这段代码，必须等待线程1执行完成后，才能执行。)

Java中处理事务原子性的方法非常简单，只需要在需要保证原子性的代码块用如下代码:

synchronized(Object){
<span style="white-space:pre">	</span>代码块
}

这就是java线程的同步机制。

package com.thread;

public class Thread3 {

	public static void main(String[] args) {
		//定义售票窗口
		TicketWindow tw1 = new TicketWindow();
		
		//创建线程
		Thread t1 = new Thread(tw1);
		Thread t2 = new Thread(tw1);
		Thread t3 = new Thread(tw1);
		
		//启动线程
		t1.start();
		t2.start();
		t3.start();
	}

}

//售票窗口类
class TicketWindow implements Runnable {
	
	//票数
	private int nums = 2000;
	
	@Override
	public void run() {
		while(true){
			//同步代码块
			synchronized (this) {
				// 判断是否有票
				if (nums > 0) {
					// 显示售票信息，currentThread().getName()获取当前线程的名字
					System.out.println(Thread.currentThread().getName() + "正在售出第" + nums + "票");
					try {
						Thread.sleep(100);
					} catch (Exception e) {
						e.printStackTrace();
					}
					nums--;
				} else {
					// 票已卖完
					break;
				}
			}
		}
	}
}

线程同步机制–深入理解

java任意类型的对象都有一个标志位，该标志位具有0、1两种状态，其开始状态为1，当某个线程执行了synchronized(Object)语句后，object对象的标志位变为0的状态，直到执行完整个synchronized语句中的代码块后，该对象的标志位又回到1状态。

当一个线程执行到synchronized(Object)语句的时候，先检查Object对象的标志位，如果为0状态，表明已经有另外的线程正在执行synchronized包括的代码，那么这个线程将暂时阻塞，让出CPU资源，直到另外的线程执行完相关的同步代码，并将Object对象的标志位变为1状态，这个线程的阻塞就被取消，线程能继续运行，该线程又将Object的标志位变为0状态，防止其它的线程再进入相关的同步代码块中。

如果有多个线程因等待同一个对象的标志位面而处于阻塞状态时，当该对象的标志位恢复到1状态时，只会有一个线程能够进入同步代码执行，其它的线程仍处于阻塞的状态。

----------参考《韩顺平.循序渐进学.java.从入门到精通》

----------参考《JDK_API_1_6_zh_CN》

Java学习笔记–导航http://blog.csdn.net//article/details/49819641