开始学习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){

}
}
}
}