java08多线程生产者和消费者

同步方法

同步方法时当前所在对象作锁旗标synchronized(this)==同步方法
代码：

class Demo1{
public static void main(String []args){
Saler s1=new Saler("s1");
Saler s2=new Saler("s2");
s1.start();
s2.start();
	}
}
//定义售票员类
class Saler extends Thread
{
static int tickets=100;//一共100张票，静态的每个对象共同拥有
static Object lock=new Object();//声明锁旗标
private String name;
public Saler(String name){
this.name=name;
}
//判断票是否小于等于1，小于1就结束，不小于1就卖出此票
public void run(){
while(true){
int t=getTicket();
if(t==-1){
return ;
	  }
	  esle {System.out.println(name+":"+t);}
		}
	}
	//定义锁旗标
	public int getTicket(){
	synchronized(lock){
	int t=tickets;
	try{
	Thread.sleep(500);
	}
	catch(Exception e){}
	tickets=tickets-1;
	return t<1?-1:t;
		}
	}
}

class Demo1{
public static void main(String []args){
Saler s1=new Saler("s1");
  Saler s2 =new Saler("s2");
  s1.start();
  s2.start();
}
}
//定义售票员类
class Saler extends Thread{
static int no=0;//服务员的代码
private String name;
private TicketPool pool;//票池

public Saler (String name,TicketPool pool)//构造函数初始化
{
this.name=name;
this.pool=pool;
}
//run()运行卖出票
public void run(){
while(true){
int no=pool.getTicket();
if(no==0){ return ;}
else {
System.out.println(name+":"+no);
Thread.yield();//放弃抢占
}
}
}
}
//票池，在上面我们把票放到了一个函数中，这里我们定义了票池
class TicketPool
{
 private int tickets=9;
 public synchronized int getTicket(){
  int temp=tickets;
  tickets=tickets-1;
  return temp>0?temp:0;
 }
}

静态方法可以加同步，不能以当前对象作为参照物,直接以类作为参照物
同步静态方法，使用类作为同步静态标记public static synchronized xxxx(..){...}

class Demo1
public static void main(String []args){
Saler s1=new Saler("s-1");
  Saler s2=new Saler("s-2");
  Saler s3=new Saler("s-3");
  Saler s4=new Saler("s-4");
  s1.start();
  s2.start();
  s3.start();
  s4.start();
}
}
//定义售票员类
class Saler extends Thread
{
static int no=0;//初始票为0
private String name;
private TicketPool pool;//哦票池
public Saler (String name){
this.name=name;
}//构造函数
public void run(){//运行时
while(true){//无数次循环，直到没票了范围空白
int no=TicketPool.getTicket();
if(no==0) return ;
esle { System.out.printlnn(name+":"+no);
Thread.yield();//放弃抢占
			}
		}
	}
}
//票池  静态的锁
class TicketPool
{
	private static int tickets=9;
	public synchronized static int getTicket(){
	int temp=tickets;
	tickets=tickets-1;
	return temp>0?temp:0;
	}
}

集合

我们都知道，数组时给定的数组长度，不能随时改变，但是集合不一样，就是一个可以随时改变的列表
集合：List：列表。java.util.List
//java.util.List<Integer>list=new
//java.util.ArrayList<Integer>();
集合里放的都是Integer对象
例如：int i=100;Integer ii=new Integer(100);ii就是一个对象了

class Demo1{
public static void main(String[]args){
java.util.List<Integer>list=new  java.util.ArrayList<Integer>();
  Productor p=new Productor("消费者",list);
  Consumer c=new Consumer("消费者",list);
   p.start();
   c.start();
   }
}
//生产者和消费者
class Productor extedns Thread
{
private String name;
private java.util.List<Integer>List;
public Productor (String name,java.util.List<Ingeter>List){
this.name=name;
this.list=list;
}
public void run(){
int i=0;
while(true){
List.add(new Integer(i++));//每次实例化一个新的对象，就是变化的长度
			}
		}
	}
	//定义一个消费者类
	class Consumer extends Thread{
	private String name;
	private java.util.List<Integer>List;
	public Consumer(String name,java.util.List<Integer>List){
	this.name=name;
	this.list=list;
}
public void run(){
/* while(true){
if(list.size()>0){//size判断集合大小
list.remove(0);
System.out.println(name+"取出了"+i);
			}*/
			//这样的话消费大于生产了
			//这样来
			/*while(true){
    if(list.size()>0){//大于0才可以取出，要不然会有异常
     int i=list.remove(0);
     try{
      Thread.sleep(2000);//取出之后休眠两秒，这样取出就小于生产了
     }
     catch(Exception e){
      System.out.println("remove:"+i+" ");}*/
      //但是这样也会出错，生产的速度远远大于消费的速度，导致集合过大，空间容纳不下，就溢出了
      //解决这个问题的方式就是设置一个最大值，不要让他无限增加。看下面代码
			
		}
	}
}

//在原来的基础上添加一个新的类

class ThreadDemo9{
public static void main(String []args){
Pool pool=new Pool();
Productor p=new Productor("生产者",pool);
Consumer c=new Consumer("消费者",poolt);
p.start();
c.start();
}
}
//生产者
calss Productor extends Thread
{
private String name;
private Pool pool;
public Productor (String name,Pool pool){
this.name=name;
this.pool=pool;
}
public void run(){
int i=0;
while(true){
pool.add(i++);
System.out.println("add"+i+" ");
		}
	}
}
//消费者
class Consumer extends Thread{
private String name;
private Pool pool;
public Consumer(String name,Pool pool){
this.name=name;
this.pool=pool;
}
public void run(){
while(true){
int i=pool.remove();
try{
Thread.sleep(100);
}
catch(Exception e){}
System.out.println("消费"+i);
		}
	}
}
class Pool{
private java.util.List<Integer>list=new java.util.ArrayList<Integer>();
//添加元素
private int Max=100;
public void add(int n){
synchronized(this){
try
while(list.size()>Max){
this.wait();//
}
esle {
list.add(n);
this.notify();
		}
	}
catch(Exception e){
e.printStackTrace()//打印栈跟踪信息
		}
	}
}
//删除元素
public void remove(){
synchronized(this){
try{
if(list.size()==0){
this.wait();//如果发现没了，就进入等待队列
}
esle {
int i=list.remove(0)
this.notify();//如果消费，通知生产
return i;
		}

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

浅谈一下：run(),start(),join();
线程中start()/run()方法的区别
start()：该方法是在当前线程中启动一个新的线程，而新启动的线程会调用run()方法同时该方法不能重复调用；
run() ：该方法和普通的方法一样，可以重复执行，不会创建新的线程。

package com.tml.javaCore.thread;
public class StartAndRunDemo {
 public static void main(String[] args) {
   Thread t1 = new  MyThread("thread_01"); 
    System.out.println("run() ...."); 
     t1.run();  
     System.out.println("start() ...."); 
      t1.start();
      //run()方法可以重复执行		
      //t1.run();	
     	//start()方法不能重复执行，重复执行会抛出java.lang.IllegalThreadStateException	
      	//t1.start();		



static class  MyThread  extends Thread{		
public  MyThread(String name){		
	super(name);	
	}
	public void run() {	
			System.out.println(Thread.currentThread().getName() + " is running!");	
				}
				
					}

join()
hread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。
比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。
t.join(); //调用join方法，等待线程t执行完毕
t.join(1000); //等待 t 线程，等待时间是1000毫秒。
wait()和sleep()
sleep():让当前线程休眠指定毫秒数，释放cpu抢占权，和锁旗标的监控权没有关系
wait():让当前线程进入锁旗标的等待队列。不仅释放cpu的抢占权，还释放锁旗标的监控权。
wait():等待通知(notify());Object。notify();通知等待线程把他们唤醒
wait()只能在同步代码块里面调用
notifyall()通知所有等待抢占