开始学习java4 线程线程

多线程操作，其实是一个将固定时间分割成时间片，在这个时间里面讲零碎时间分配给不同的线程，然后这些线程会在固定的时间

段内完成，它们给予分配的时间是不固定的，一会儿执行这个，一会儿执行那个。

标记多线程需要借助类 Thread类 该类构造方法需要一个实现Runnable接口的类，在Runnable接口下重写它的run的方法。

Thread a = new Thread([这里需要实现runnable接口的类]) 然后start()则标记函数执行。

或者直接继承Thread类，然后重写Run()的方法，然后外面实例化后调用start()方法。start()执行的时候并不是马上运行，而是在cpu标记需要执行,标记时间有份残余分割。

利用Sleep的方法 暂停多少毫秒然后再接着继续执行。在哪个线程里面调用Thread调用sleep()方法，那个线程就要停止多少时间。

public class Hello {
	
	public static void main(String[] args)
	{
		
		TestThread a = new TestThread();
		
		a.start();
		try{
			
			Thread.sleep(10000);
		}catch(InterruptedException er){
			
//			
		}
		a.flag = false;
		
	}
}


class TestThread extends Thread{
	
	public boolean flag = true;
	public void run(){
		
		
	
		while(flag){
			System.out.println(new Date());
			try{
				
				sleep(1000);
			}catch(InterruptedException er){
				
				return;
			}
		}
	}
}

通过setPriority(Thread,NORM_PRIORITY + ?) 这个事设置某线程的优先级别，Thread里面有静态常量表示优先级别。

Thread类中有join的方法，即是将该线程加进当前的线程中，然后需要改方法执行完毕之后，才会执行随后的方法。

Thread中的yield()的方法，可以缓冲,给予其他线程优先,本身先缓一缓。

通过Thread 中的super可以通过不同的参数名称分不同，getName获取该类名称。

线程锁定操作：

例子 ：银行柜台取钱与外部柜员机取钱同时进行的时候，如何进行判断，如果在验证余额是否大于取款数的时候，被打断，外部柜员机也同时干预

进来验证余额方法，会导致获取的余额数目一样，从而可以提取相同的钱，而导致剩余的余额一样。

解决的方法，当在验证余额是否大于取款数的时候，将该方法锁定，只有等该方法执行完毕之后，才会开放出来给予其他需要的调用。

利用synchronized的修饰符 public synchronized void Main(){}的修饰符，或者是在方法内部 synchronized(){}再给予这样的锁定限制。

只要在Thread开放了至少2条线程下，synchronized才有效果，才能够避免其他线程下的进度干扰到当前线程的进度，通过synchronized锁定

当前线程，才会只让它专注于当前线程，只有等当前线程结束之后才会进行其他的线程操作。而且仅当synchronized修饰符下wai()的进程才有

效果，同时才会由notify()的唤醒其他被wait()状态下的进程。例子：消费者与生产者模式：

public class Hello{
	
	public static void main(String[] args){
		
		Basket basket = new Basket();
		//两个进程 加上本身的main进程有三条进程
		//参量均为同个篮子
		Producer p = new Producer(basket);  
		Consumer c = new Consumer(basket);
		new Thread(p).start();
		new Thread(c).start();
		
	}
}

class Bread{
	
	int i = 0;
	Bread(int i ){
		
		this.i = i;
	}
}

/**
 * 
 * 盛放面包的篮子
 *
 */
class Basket{
	int index = 0; //当前篮子的面包数
	Bread[] bread = new Bread[20];//存放面包的数组
	public synchronized void push(Bread bread){ //面包存放函数
		
		while(index == this.bread.length){
			
			try{
				
			this.wait(); //当篮子装满情况下暂停装面包
			}catch(InterruptedException e){
				
				
			}
		}
		this.notify();//提醒外部wait进程可恢复工作
		this.bread[index] = bread;
		index++;
		
	}
	
	public synchronized Bread pop(){//面包消耗函数
		
		while(index == 0){
			
			try{
				
				this.wait(); //当篮子面包为空暂停消耗
			}catch(InterruptedException e){
				
				
			}
		}
		this.notify();
		index--;
		return this.bread[index];
		
	}
}


class Producer implements Runnable{//生产面包工人
	Basket basket = null;
	Producer(Basket basket){
		
		this.basket = basket;
	}
	public void run(){
		
		while(true){
			
			basket.push(new Bread((int)(Math.random())* 100));
			System.out.println("生产中:...." + basket.index);
			try{
				
				Thread.sleep((int)(Math.random() * 1000));//随机睡眠时间,效果即是随机时间进行生产
			}catch(InterruptedException e){
				
			}
		}
		
	}
	

}

class Consumer implements Runnable{ //面包消耗者
	
	Basket basket = null;
	 Consumer(Basket basket) {
	
		this.basket = basket;
	}
	public void run(){
		
		while(true){
			
			
			basket.pop();
			System.out.println("消费中:...." + basket.index);
			try{
				
				Thread.sleep((int)(Math.random() * 1000));//随机消耗时间，效果是随机时间消耗面包
			}catch(InterruptedException e){
				
				
			}
		}
	}
}