【Java】java的多线程，

【Java】java的多线程，

 

迷之被骂 心情也不爽 正好还要等3个小时球赛 学习下吧~

 

----------------1  .线程的状态， 可分为：

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

---------2.多线程的实现方式

1.扩展java.lang.Thread类

 

(1)class MyThread extends Thread{
public MyThread(String n)
{
super(n);
}
public void run(){
for(int i=0;i<5;i++)
{
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(getName());
}
}
}

启动需要调用start方法

2.实现java.lang.Runnable接口：

class MyThread implements Runnable{
String name;
public MyThread(String n)
{
name=n;
}
public String getName(){
return name;
}
public void run(){
for(int i=0;i<5;i++)
{
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(getName());
}
}
}

启动方法：new Thread(new MyThread("a")).start();

 

两种方法比较：Thread是java中已经封装好的类 对一个类进行修改或扩充 会出现不可预料的错误。而且是java不支持多继承 继承了Thread类后 将不能继承其它类。Runnable的缺点是，在run（）方法中如果需要调用进程自身方法 需要调用Thread。currentThread()方法以获得对当前线程自身的引用。

-----------3.线程的生命周期：

线程的各种状态及相互转换如上图所示。

 

 

-----------4.线程同步：

1.生产者跟消费者问题：生产者 消费者 Box 产品

synchronized关键字

synchronized方法 synchronized块：

synchronized（syncObject）{

。。。}

1.两个线程不能同时对box进行操作。

2.两个线程必须协同工作 生产者必须消费者产品已经产生 消费者取走产品之后 通知消费者可以重新写入数字。

package threadtest;
class product//产品类
{
	String id;
	public product(String a){
		this.id=a;
	}
    public String toString(){  
        return "产品:"+id;  
    } 	
}
class box{//仓库
	int index = 0; 
	product[] probox=new product[5];
	public synchronized void  push(product pro){
		while(index==probox.length){
			System.out.println("满了 过会再来生产");
			try {  
                this.wait();//让当前线程等待  
            } catch (InterruptedException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace(); }}
			 this.notify();//唤醒在此对象监视器上等待的单个线程，即消费者线程  
		        probox[index] = pro;  
		        this.index++;  
		
	}
	   public synchronized product pop(){  
	        while(index==0){//筐空了，即栈空  
	            try {  
	                this.wait();  
	            } catch (InterruptedException e) {  
	                // TODO Auto-generated catch block  
	                e.printStackTrace();  
	            }  
	        }  
	        this.notify();  
	        this.index--;//push第n个之后，this.index++，使栈顶为n+1，故return之前要减一  
	        return probox[index];  
	    } 
}
	class Producer implements Runnable{
		String name;
		box b;
		public Producer(box bb,String name)
		{
			this.name=name;
			this.b=bb;
	}
		public void run()
		{
			for(int i=0;i<20;i++){
				
				product pro=new product("name"+i);
				b.push(pro);
				System.out.println(name+"生产了"+pro);
			
			try {  
                Thread.sleep(10);//每生产一个馒头，睡觉10毫秒  
            } catch (InterruptedException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
		}
		}
	}
	class Cosumer implements Runnable{
		String name;
		box b;
	
    public Cosumer(box bb ,String name) {  
       super();
       this.b=bb;
       this.name=name;
    }  
    public void run(){
    	// TODO Auto-generated method stub
    	for(int i=0;i<10;i++){
    		
    		product p=b.pop();
    		 System.out.println("消费了"+p);  
    		 try {  
                 Thread.sleep(100);//每消费一个馒头，睡觉100毫秒。即生产多个，消费一个  
             } catch (InterruptedException e) {  
                 // TODO Auto-generated catch block  
                 e.printStackTrace();  
             }  
    	}
    }
    
	}
	


public class ProduceConsume {
public  static void main(String args[]){
	box b=new box();
	Producer p1=new Producer(b,"小王");
	
	Cosumer c =new Cosumer(b,"小张");Cosumer c2 =new Cosumer(b,"小1张");
	
	Thread tp1=new Thread(p1);
	Thread tc=new Thread(c);
	Thread tc2=new Thread(c2);
	tp1.start();tc.start(); tc2.start();
}

}