JavaSE基础复习六：多线程

------- android培训、 java培训、期待与您交流！ ----------

创建线程两种方法：继承Thread类或者实现Runnable接口

一：继承Thread类。 

步骤： 
1、定义一个类继承Thread类。 
2、覆盖Thread类中的run方法。 
3、直接创建Thread的子类对象创建线程。 
4、调用start方法开启线程并调用线程的任务run方法执行。 
通过getName()方法获取线程名，默认名称：Thread-编号(从0开始) 

二：实现Runnable接口。 

1、定义类实现Runnable接口。 
2、覆盖接口的run()方法，将线程的任务代码封装到run()方法中。 
3、创建Thread对象，将Runnable接口的子类对象作为Thread类构造函数的参数传递。  
4、调用Thread对象的start()方法开启线程。

Thread ：如果没有父类可以继承Thread
Runnable ：避免了单继承的局限性，建议采用实现接口方式创建线程

线程安全问题产生原因：

1、多个线程操作共享数据时。
2、操作共享数据的代码有多条代码。
在一个线程操作的过程中，其他线程可以参与进来。

线程状态转换

synchronized  同步锁：

同步代码块：锁是一个对象；  
同步函数：锁其实是this；
静态同步函数：锁是 类名.class  它是一个Class类的字节码文件对象

/*
卖票程序
同步代码块形式
*/

class Ticket implements Runnable {  //接口没有抛出异常，所以run()方法内只能捕捉异常
	
	private int num = 100;
	Object obj = new Object();
	
	public void run() {

		while(true) {
			try{
				Thread.sleep(100);//---测试多线程调用时，数据num出现负数
			}catch(InterruptedException e) {
				System.out.println("线程出错了");	
			}			
			synchronized(obj){
				if(num>0){
					System.out.println(Thread.currentThread().getName() + "----- sale ----" + num--);
				}
			}	
		}	
	}	
}

class TicketDemo {
	public static void main(String[] args) {
		
		Ticket t = new Ticket();//---只有一个Ticket对象
		Thread t1 = new Thread(t);
//		Thread t2 = new Thread(new Ticket());
//		Thread t3 = new Thread(new Ticket());
//		Thread t4 = new Thread(new Ticket()); //---4个Ticket对象需要使用static修饰num
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
			
	}	

举例：火车上的卫生间

同步的好处：解决了线程的安全问题。 
同步的弊端：相对降低了效率，因为同步外的线程的都会判断同步锁。 
同步的前提：有多个线程并使用同一个锁。

单例设计模式：

使类只有一个对象（构造函数私有化，在类中创建本类对象并私有化为静态，定义公共静态方法，通过调用返回对象）
饿汉式：对象在类进入内存中时加载。不存在线程安全的问题
懒汉式：对象延迟加载。使用同步代码块，锁是类名.class，并在锁外在进行一次判断（双层判断）。可以防止加锁浪费资源。

/*
多线程下的单例设计模式

*/
//---饿汉式
class SingleHg {
	private static final SingleHg s = new SingleHg();
	private SingleHg(){}
	
	public static SingleHg getInstance(){
		return s;	
	}
}

//---懒汉式
class SingleLz {
	private static SingleLz s = null;
	private SingleLz(){}
	
	public static SingleLz getInstance(){
		if(s==null)
			s = new SingleLz();
		return s;	
	}
}

//---加同步锁的懒汉式，面试常考，一般实际用饿汉式

class Single {
	private static Single s = null;
	private Single(){}
	
	public static /*synchronized*/ Single getInstance(){ //---使用同步函数会降低效率，每次都要获取锁
		if(s==null)
			synchronized(Single.class){
				if(s==null)
					s = new Single();
			}	
		return s;	
	}
}

死锁程序：

Interrupt();强制清除线程的冻结状态，使线程获取执行资格，但是会使线程抛出InterruptedException

线程间通信：其实是多个线程在操作同一个资源，只是操作的动作不同；

考虑同步问题，加入等待唤醒机制；wait()  notify()
wait();notify();notifyAll(); 这些方法都应该在同步代码中使用，对持有锁的线程进行操作。
这些方法都定义在Object类中，所有对象都可以是锁，这些方法只能唤醒或者等待持有相同锁的线程。

生产者消费者问题：

多个生产者消费者，需要用while()循环判断标记；

class Duck {
	private int id;
	Duck(int id) {
		this.id = id;
	}
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	@Override
	public String toString() {
		return "Duck [id=" + id + "]";
	}	
}

class DuckBasket {
	int index = 0;
	Duck[] ducks = new Duck[5];
	
	public synchronized void push(Duck duck) {
		while(index==ducks.length)
			try {
				System.out.println(Thread.currentThread().getName()+"：篮子满了，歇会~~~~~~~~~！");
				this.wait();
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		ducks[index] = duck;
		System.out.println(Thread.currentThread().getName()+"生产了"+duck);			
		index++;
		notify();
	}
	
	public synchronized Duck pop() {
		while(index==0)
			try {
				System.out.println(Thread.currentThread().getName()+"：空了，快生产烤鸭！");
				wait();
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		index--;
		//---打印输出用到了共享数据，要放到同步代码中
		System.out.println(Thread.currentThread().getName()+"消费了"+ducks[index]);		
		notify();
		return ducks[index];
	}
}

class Producer implements Runnable {
	DuckBasket db;
	public Producer(DuckBasket db) {
		super();
		this.db = db;
	}
	
	@Override
	public void run() {
		for(int i=0; i<20; i++) {
			Duck duck = new Duck(i);
			db.push(duck);		
		}
	}
}

class Consumer implements Runnable {
	DuckBasket db;
	public Consumer(DuckBasket db) {
		super();
		this.db = db;
	}
	
	@Override
	public void run() {
		for(int i=0; i<20; i++) {
			db.pop();
		}
	}	
}

public class ProducerConsumerDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		DuckBasket db = new DuckBasket();
		Producer pro1 = new Producer(db);
		Consumer con1 = new Consumer(db);
		Thread t1 = new Thread(pro1,"生产者----1");
		Thread t2 = new Thread(con1,"消费者1");
		Thread t3 = new Thread(pro1,"生产者----2");
		Thread t4 = new Thread(con1,"消费者2");
		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}

}

新特性，多线程的升级解决方案，将同步的synchronized 升级为显示的lock(接口)，
将wait(),notify(),notifyAll()升级为condition对象，该对象可以通过lock锁获取。
可以实现只唤醒对方的操作。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


class Duck {
	private int id;
	Duck(int id) {
		this.id = id;
	}
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	@Override
	public String toString() {
		return "Duck [id=" + id + "]";
	}	
}

class DuckBasket {
	int index = 0;
	Duck[] ducks = new Duck[5];
	Lock lock = new ReentrantLock();
	Condition proL = lock.newCondition();
	Condition conL = lock.newCondition();
	
	public void push(Duck duck) {
		lock.lock();
		try{
			while(index==ducks.length)
				try {
					System.out.println(Thread.currentThread().getName()+"：篮子满了，歇会~~~~~~~~~！");
					proL.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			ducks[index] = duck;
			System.out.println(Thread.currentThread().getName()+"做了"+duck);			
			index++;
			conL.signal();
		}finally{
			lock.unlock();
		}
	}
	
	public Duck pop() {
		lock.lock();
		try {
			while(index==0)
				try {
					System.out.println(Thread.currentThread().getName()+"：空了，快做烤鸭！");
					conL.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			index--;
			//---打印输出用到了共享数据，要放到同步代码中
			System.out.println(Thread.currentThread().getName()+"消费了"+ducks[index]);		
			proL.signal();
			return ducks[index];
		} finally{
			lock.unlock();
		}
	}
}

class Producer implements Runnable {
	DuckBasket db;
	public Producer(DuckBasket db) {
		super();
		this.db = db;
	}
	
	@Override
	public void run() {
		for(int i=0; i<20; i++) {
			Duck duck = new Duck(i);
			db.push(duck);		
		}
	}
}

class Consumer implements Runnable {
	DuckBasket db;
	public Consumer(DuckBasket db) {
		super();
		this.db = db;
	}
	
	@Override
	public void run() {
		for(int i=0; i<20; i++) {
			db.pop();
		}
	}	
}

public class ProConLock {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		DuckBasket db = new DuckBasket();
		Producer pro1 = new Producer(db);
		Consumer con1 = new Consumer(db);
		Thread t1 = new Thread(pro1,"生产者----1");
		Thread t2 = new Thread(con1,"消费者1");
		Thread t3 = new Thread(pro1,"生产者----2");
		Thread t4 = new Thread(con1,"消费者2");
		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}

如何停止线程？

1、控制循环，做一个标记，使标记改变时满足条件就停止循环，结束run()方法；
2、如果线程处于等待（冻结）状态，无法结束线程，可以使用interrupt()方法强制解除冻结状态，进入运行状态，这样就可以操作标记，结束线程。

wait()和sleep()相同点，都可以使线程进入冻结状态，都抛出异常。

区别：
1、wait()为Object的方法，sleep()为Thread的方法
2、wait()必须有锁
3、wait()需要notify()唤醒，sleep()时间到了自动获取CPU执行资格

其他方法

join()方法，当a线程执行到了b线程的join方法时，a等待b执行完在继续执行。


setDaemon();守护进程，前台结束就结束


Thread类的 toString()方法，返回  [程名称，优先级，线程组]


setPriority()设置优先级  MAX_PRIORITY  MIN_PRIORITY NORMAL_PRIORITY   setName()  


yield();静态方法：暂停当前线程执行

匿名内部类创建进程---常用。

-------  android培训、 java培训、期待与您交流！ ----------