JAVA多线程

进程和线程

进程：进程是程序的一次执行活动，一个进程包含1--n个线程
线程：线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位，是进程中执行运算的最小单位

线程的状态：创建，就绪，执行，阻塞，结束

1 进程的实现方式一   继承Thread

案例1 

package cjr;

public class ThreadDemo1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyThread my1=new MyThread();
		MyThread my2=new MyThread();
		my1.start();
		my2.start();
	}

}
class MyThread extends Thread
{
	public void run()
	{
		for(int i=0;i<5;i++){
			try {
				Thread.sleep(10);
			} catch (Exception e) {
			}
			System.out.println(Thread.currentThread().getName() + " : " +i);
		}
	}
}

运行结果：

Thread-0 : 0
Thread-1 : 0
Thread-0 : 1
Thread-1 : 1
Thread-1 : 2
Thread-0 : 2
Thread-0 : 3
Thread-1 : 3
Thread-0 : 4
Thread-1 : 4

继承Thread,需修改run()方法,里面填写自己要执行的任务。

当主线程main执行到 new MyThread() ,创建了一个线程，并通过Start() 方法将线程状态更改为就绪状态， 等待CPU调用。 当CPU调用到该线程，会执行run()方法
注：

1. 多线程代码执行顺序都是不确定的，因此每次执行的结果都是随机的
2. 当线程状态为就绪状态，该线程不能再一次调用start()方法，否则会引发java.lang.IllegalThreadStateException异常
3. 若调用my1.run() ,同样会执行MyThread()里的run()方法，但是未开启新的线程，而是main线程执行了run()里的任务。

2 进程的实现方式二   实现Runnable接口

继承Thread类， 继承Thread所有的方法属性信息，  而我们更多时候只是为了通过创建另一个线程，执行我们的任务而已，并且继承了Thread类就无法继承其它父类信息。因此引入Runnable接口实现多线程方式

案例2 

package cjr;

public class ThreadDemo2 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyJob job1=new MyJob();
		MyJob job2=new MyJob();
		Thread t1=new Thread(job1);
		Thread t2=new Thread(job2);
		t1.start();
		t2.start();
	}

}
class MyJob implements Runnable
{
	@Override
	public void run()
	{
		for(int i=0;i<5;i++){
			try {
				Thread.sleep(10);
			} catch (Exception e) {
			}
			System.out.println(Thread.currentThread().getName() + " : " +i);
		}
	}
}

同样可以得到运行结果：

Thread-0 : 0
Thread-1 : 0
Thread-0 : 1
Thread-1 : 1
Thread-0 : 2
Thread-1 : 2
Thread-0 : 3
Thread-1 : 3
Thread-1 : 4
Thread-0 : 4

通过实现Runnable接口，使得该类有了多线程类的特征。run（）方法是多线程程序的一个约定。所有的多线程要执行的代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。

实现Runnable接口比继承Thread类所具有的优势：

1. 适合多个相同的程序代码的线程去处理同一个资源
2. 可以避免java中的单继承的限制
3. 增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

3 线程的状态

1、新建状态：新创建了一个线程对象。
2、就绪状态：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
3、运行状态：就绪状态的线程获取了CPU，执行程序代码。
4、阻塞状态：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
5、死亡状态：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

线程的状态变化

                 

4 Thread 常用方法及说明

4.1 常用方法

getName()       返回该线程的名称。
getPriority()     返回线程的优先级。
getState() 返回该线程的状态
interrupt() 将线程状态更改为可执行状态， 注：并不一定中断线程（唤醒的线程再次被阻塞的话，线程不会中断）
join() 将线程任务排在当前执行线程之前，暂停当前线程
setName(String name) 改变线程名称
setPriority(int newPriority) 更改线程的优先级。

setDaemon(boolean on)  将该线程标记为守护线程或用户线程,true为守护线程

静态方法
currentThread()          返回对当前正在执行的线程对象的引用
sleep(long millis)       将当前线程从正在执行状态更改为阻塞状态，在millis毫秒后恢复为就绪状态。
yield()             暂停当前正在执行的线程对象，并执行其他线程

4.2 线程类型

线程分 守护线程（后台线程）和用户线程（前台线程）

守护线程：当所有用户线程执行结束， 守护线程会被终结，程序结束。守护线程新建的线程默认为守护线程 

用户线程：当除此之外的所有用户线程结束， 而自己没有结束， 则自己不会被终结，程序不会结束。用户线程新建的线程默认为用户线程

更改线程类型  setDaemon(boolean on) 

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。main线程就是用户线程，垃圾收集线程就是守护线程

4.3 线程优先级

Java线程的优先级用整数表示，取值范围是1~10,数字越大，优先级越高，优先级高的线程会获得较多的运行机会

Thread类有以下三个静态常量：
static int MAX_PRIORITY
          线程可以具有的最高优先级，取值为10。
static int MIN_PRIORITY
          线程可以具有的最低优先级，取值为1。
static int NORM_PRIORITY
          分配给线程的默认优先级，取值为5。

Thread类的setPriority()和getPriority()方法分别用来设置和获取线程的优先级。

main线程的默认优先级是NORM_PRIORITY ,由main线程创建的其它线程优先级默认也是NORM_PRIORITY 。  当将main线程优先级更改为6，则有main线程创建的线程优先级也是6， 即线程是有继承性的。

5 线程同步

当多个线程访问统一资源对象， 而资源对象会动态变更时， 就会造成线程安全问题。 如两个售票站同时售票， 就有可能同时售出同一张票。为杜绝该事情发生，在售票员1售票A时，售票员2不能操作票A。

5.1 同步代码块

    案例3

public class TicketDome {
	public static void main(String[] args)
	{
		Thread.currentThread().setPriority(6);
		Ticket ticket=new Ticket();
		Thread t1=new Thread(ticket);
		Thread t2=new Thread(ticket);
		t1.start();
		t2.start();
	}
}

class Ticket implements Runnable
{
	private int num=10;
	private Object lock=new Object(); 
	
	@Override
	public void run() {
		try {
			while(true)
				sale();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	private void sale() throws InterruptedException{
		synchronized (lock) {//线程安全代码块
			if(num>0){
				Thread.sleep(100);
				System.out.println("saled by "+ Thread.currentThread().getName()+";  TicketNum--" + num--);
			}
		}
	}
}

输出结果：

saled by Thread-1;  TicketNum--10
saled by Thread-1;  TicketNum--9
saled by Thread-1;  TicketNum--8
saled by Thread-0;  TicketNum--7
saled by Thread-0;  TicketNum--6
saled by Thread-0;  TicketNum--5
saled by Thread-1;  TicketNum--4
saled by Thread-1;  TicketNum--3
saled by Thread-1;  TicketNum--2
saled by Thread-1;  TicketNum--1

lock 为对象锁，当线程Thread-0 访问synchronized里代码时，Thread-1无法获取锁对象，即无法访问同步代码块里的内容。
注：当使用对象锁时，请确认多个访问的是否是同一个对象锁

5.2 同步方法

如上例中的sale()方法中，所有带代码都是同步代码块， 则可以将同步代码块提炼成同步函数
案例四

public class TicketDome {
	public static void main(String[] args)
	{
		Thread.currentThread().setPriority(6);
		Ticket ticket=new Ticket();
		Thread t1=new Thread(ticket);
		Thread t2=new Thread(ticket);
		t1.start();
		t2.start();
	}
}

class Ticket implements Runnable
{
	private int num=10;
	private Object lock=new Object(); 
	
	@Override
	public void run() {
		try {
			while(true)
				salesafe();//调用同步方法
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	private void sale() throws InterruptedException{
		synchronized (lock) {//线程安全代码块
			if(num>0){
				Thread.sleep(100);
				System.out.println("saled by "+ Thread.currentThread().getName()+";  TicketNum--" + num--);
			}
		}
	}
	private synchronized void salesafe() throws InterruptedException{//同步函数
		if(num>0){
			Thread.sleep(100);
			System.out.println("saled by "+ Thread.currentThread().getName()+";  TicketNum====" + num--);
		}
	}
}

运行结果

saled by Thread-1;  TicketNum====10
saled by Thread-1;  TicketNum====9
saled by Thread-1;  TicketNum====8
saled by Thread-0;  TicketNum====7
saled by Thread-0;  TicketNum====6
saled by Thread-0;  TicketNum====5
saled by Thread-1;  TicketNum====4
saled by Thread-1;  TicketNum====3
saled by Thread-1;  TicketNum====2
saled by Thread-1;  TicketNum====1




注：

1. 同步方法使用的对象锁是this对象；
2. synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}
3. 当synchronized修饰一个static方法时，获取的是类锁（即Class本身，this.getClass()，注意：不是实例）；

6 死锁

当同一代码块多个锁对象，在多线程模式下，可能会造成死锁。比如有两把锁A和B,线程1获取了A锁对象等待获取B锁对象访问资源，线程2获取了B锁对象等待获取A锁访问资源，两线程同时在等待，且不释放自身的锁对象，即会引发死锁。




案例5 死锁

public class DeadLockDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Thread t1=new Thread(new Resource1());
		t1.setName("A");
		Thread t2=new Thread(new Resource2());
		t2.setName("B");
		t1.start();
		t2.start();
	}

}

class Resource1 implements Runnable
{
	
	@Override
	public void run() {
		while(true){
			synchronized (MyLock.lock1) {
				System.out.println(Thread.currentThread().getName()+" :  --获取lock1,等待lock2");
				synchronized (MyLock.lock2) {
					System.out.println(Thread.currentThread().getName()+" :  --已获取lock2，线程结束");
				}
			}
		}
	}
}

class Resource2 implements Runnable
{
	
	@Override
	public void run() {
		while(true)
		{
			synchronized (MyLock.lock2) {
				System.out.println(Thread.currentThread().getName()+" :  --获取lock2，等待lock1");
				synchronized (MyLock.lock1) {
					System.out.println(Thread.currentThread().getName()+" :  --已获取lock1，线程结束");
				}
			}
		}
	}
}
class MyLock{
	public static Object lock1=new Object();
	public static Object lock2=new Object();
}

运行结果：

B :  --获取lock2，等待lock1
A :  --获取lock1，等待lock2

解决死锁办法：
　　1)、让所有的线程按照同样的顺序获得一组锁。这种方法消除了 A 和 B 的拥有者分别等待对方的资源的问题。


　　2)、将多个锁组成一组并放到同一个锁下。前面Java线程死锁的例子中，可以创建一个银器对象的锁。于是在获得刀或叉之前都必须获得这个银器的锁。


　　3)、将那些不会阻塞的可获得资源用变量标志出来。当某个线程获得银器对象的锁时，就可以通过检查变量来判断是否整个银器集合中的对象锁都可获得。如果是，它就可以获得相关的锁，否则，就要释放掉银器这个锁并稍后再尝试。

7 线程等待wait()  notify() notifyAll()

wait()、notify()、notifyAll()是三个定义在Object类里的方法，可以用来控制线程的状态。
这三个方法最终调用的都是jvm级的native方法。随着jvm运行平台的不同可能有些许差异。
    如果对象调用了wait方法就会使持有该对象的线程把该对象的控制权交出去，然后处于等待状态。
    如果对象调用了notify方法就会通知某个正在等待这个对象的控制权的线程可以继续运行。
    如果对象调用了notifyAll方法就会通知所有等待这个对象控制权的线程继续运行
Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作

案例： 有一输入设备Input，输出设备Ouput，Input对资源进行赋值，output取值。实现Input和out以多线程形式一次操作。

案例6 wait()

public class ThreadWaitDome {
	public static void main(String[] args)
	{
		Resource resource=new Resource();
		Input input=new Input(resource);
		Output output=new Output(resource);
		Thread t0=new Thread(input);
		Thread t1=new Thread(output);
		t0.start();
		t1.start();
	}
}

class Resource
{
	private String name;
	private String address;
	private boolean canRead=false;
	public synchronized void set(String name,String address) throws InterruptedException
	{
		if(canRead)
			wait();
		this.name=name;
		this.address=address;
		this.canRead=true;
		notify();
	}
	public synchronized void read() throws InterruptedException
	{
		if(!canRead)
			wait();
		System.out.println(Thread.currentThread().getName()+" : "+name+" ======== " +address );
		this.canRead=false;
		notifyAll();
	}
}

class Input implements Runnable
{
	private Resource resource;
	public Input(Resource res){
		this.resource=res;
	}

	@Override
	public void run() {
		int i=0;
		while(true)
		{
			if(i==0)
				try {resource.set("陈佳仁", "杭州滨江");} catch(InterruptedException e){}
			else 
				try {resource.set("cjr", "HangZhou");} catch(InterruptedException e){}
			i=(i+1)%2;
		}
	}
}

class Output implements Runnable
{
	private Resource resource;
	public Output(Resource res){
		this.resource=res;
	}

	@Override
	public void run() {
		while(true)
			try {this.resource.read();} catch(InterruptedException e){}
	}
}

部分运行结果：

Thread-1 : 陈佳仁 ======== 杭州滨江
Thread-1 : cjr ======== HangZhou
Thread-1 : 陈佳仁 ======== 杭州滨江
Thread-1 : cjr ======== HangZhou
Thread-1 : 陈佳仁 ======== 杭州滨江
Thread-1 : cjr ======== HangZhou

wait()偏重于控制线程的执行顺序， sleep偏重于控制线程延缓执行时间。

    wait和sleep区别
共同点： 
1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。 
2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException。 
不同点： 
1. sleep,yield()是Thread类的方法
    wait(),notify(),notifyAll() 是Object的方法

2.wait可以带参数也可以不带参数，带参数可以自己唤醒，不带参数只能由其它线程唤醒； sleep必须带参数，自我唤醒。
3. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。 
   sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。 
4. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用 
5. sleep，wait必须捕获异常，notify和notifyAll不需要捕获异常

所以sleep()和wait()方法的最大区别是：
　　　　sleep()睡眠时，保持对象锁，仍然占有该锁；
　　　　而wait()睡眠时，释放对象锁。

8 Lock  Condition  锁 监视器 

Condition的功能类似在传统线程技术中的Object.wait()和Object.natify()的功能，传统线程技术实现的互斥只能一个线程单独干，不能说这个线程干完了通知另一个线程来干，Condition就是解决这个问题的，实现线程间的通信。

常规synchronized代码块中，只有一个锁对象即相应的一个监视器。Lock可以实现一个锁对象，多个监视器（Conditon）,多线程中可以将线程阻塞在不同的监视器缓冲区中（同一个锁对象）， 也可以根据不同的监视器缓冲区唤醒监视器中的线程。

阻塞线程方法 await();     唤醒线程方法signal() signalAll()

案例7   Lock condition

public class ThreadWaitDome {
	public static void main(String[] args)
	{
		Resource resource=new Resource();
		Input input=new Input(resource);
		Output output=new Output(resource);
		Thread t0=new Thread(input);
		Thread t1=new Thread(output);
		t0.start();
		t1.start();
	}
}

class Resource
{
	private String name;
	private String address;
	private boolean canRead=false;
	private Lock lock = new ReentrantLock(); // 锁
    private Condition readCondition = lock.newCondition(); // 读取条件
    private Condition setCondition = lock.newCondition(); // 写入条件
	
	
	public void set(String name,String address) throws InterruptedException
	{
		lock.lock();
		if(canRead)
			setCondition.await();
		this.name=name;
		this.address=address;
		this.canRead=true;
		readCondition.signal();
		lock.unlock();
	}
	public  void read() throws InterruptedException
	{
		lock.lock();
		if(!canRead)
			readCondition.await();
		System.out.println(Thread.currentThread().getName()+" : "+name+" ======== " +address );
		this.canRead=false;
		setCondition.signal();
		lock.unlock();
	}
}

class Input implements Runnable
{
	private Resource resource;
	public Input(Resource res){
		this.resource=res;
	}

	@Override
	public void run() {
		int i=0;
		while(true)
		{
			if(i==0)
				try {resource.set("陈佳仁", "杭州滨江");} catch(InterruptedException e){}
			else 
				try {resource.set("cjr", "HangZhou");} catch(InterruptedException e){}
			i=(i+1)%2;
		}
	}
}

class Output implements Runnable
{
	private Resource resource;
	public Output(Resource res){
		this.resource=res;
	}

	@Override
	public void run() {
		while(true)
			try {this.resource.read();} catch(InterruptedException e){}
	}
}