java多线程的同步 通信以及生产消费者问题

Demo1

/* Runable接口比直接从Thread继承方便的多 。
* new Thread(...) ;这样即使我们传递了同一个实现了Runnable接口的多个对象那么 也是多个线程 ,而且多个线程共享数据域.
* 否则new Thread 创建的多个线程之间 互不相干 ，数据之间互不干涉
* 同步就是为了实现 在多个线程同时对一个资源进行操作的时候 要一个一个的执行 ,
* 只有等占有CPU的 线程完事之后 其他等待线程才能进入就绪状态等待运行
* java中可以用 synchrozined(Object obj){} 实现代码块的同步 参数是任意对象
* 不但可以利用synchronized语句块 也可以在方法的前面 声明 synchronized
* 同步原理是对象的标志位 初始为1 当进入代码块后 obj的标志位变为 0 这时候其他线程则不能 进入代码块执行 而进入等待状态
* 直到先进入的那个线程完事然后就会为这个线程解锁 。 其他线程才可能开始运行 火车票的售票系统就是一个多线程很好的运用的例子
* 同步是以程序的性能为代价的 ,同步方法是以类的this对象为同步对象的 而 synchronized块是以我们指定的对象为 同步对象
* 如果想让代码块和同步方法同步那么 使用的同步对象 必须都为this
*/
public class ThreadDemo2
{
public static void main(String []args)
{
MyThread mt=new MyThread() ;
//mt.start() ;
new Thread(mt) .start() ;
try
{
Thread.sleep(10) ; //每当产生一个线程CPU不会立马去执行 ，这之间既有一个微小的时间间隔 。
}
catch(Exception e)
{
System.out.println(e.toString()) ;
}
mt.str="method";
new Thread(mt) .start() ;
}
}
class MyThread implements Runnable// extends Thread
{
int tickets=100 ;
String str=new String("");
public void run()
{
if(str.equals("method"))
{
while(true)
{
running() ;
}
}
else
{
while(true)
{
synchronized(str)
{
if(tickets>0 )
{
System.out.println("block:"+Thread.currentThread().getName()+"sells"+tickets--);
}
}

}
}
}
public synchronized void running()
{
if(tickets>0)
{
try{Thread.sleep(10);}catch(Exception ex){}
System.out.print("method：") ;
System.out.println(Thread.currentThread() +"sell " + tickets-- ) ;
}
}
}

Demo2:

/*
* java多线程中 有前台线程和后台线程，前台线程 是指 main所在的主线程 和其他 创建的线程 ,如果在线程调用start 之前调用 setDeamon(true)
* 那么 这个线程就是一个后台线程,在进程中如果没有一个前台线程 那么后台线程也随之退出,从而进程也退出 。如果没有调用setDeamon(true)或者
* 调用setDeamom(false)那么这个线程就是前台线程 ,只要一个进程中还存在前台线程 那么即使mian方法所在的线程退出了 ,那么这个前台子线程也会继续执行
* 直至退出 。
* Tread类额join方法 是将一个线程合并到另一个线程中, 可以设置合并的时间间隔
* 我们实现自己的线程类有2中方法 :
* 1、直接从Thread继承而来 实现 run方法 。
* 2、实现Runnable接口,并且实现run方法 。 Thread th=new Thread(....) ;//吧我们自己实现的类的对象作为参数传进去 .
* join 方法可以将一个线程合并到另一个线程 中 而且还可以指定线程合并的时间间隔
*
*/
public class ThreadDemo1
{
public static void main(String[]args)
{
//MyThread tt=new MyThread() ; tt.start() ;可以从 Thread类派生一个线程类
Thread tt=new Thread(new MyThread()) ; //可以通过Thread类的带参数的构造方法 传递一个实现了Runnable接口的对象
// tt.setDaemon(true) ;//将线程设置为 后台线程 主线层退出这个线程也会随着退出
tt.start() ;
int index=0 ;
while(true)
{
if(index++==100)
try{
tt.join(5000) ;
}
catch(Exception ex)
{
System.out.println(ex.toString()) ;
}

System.out.println("run:"+Thread.currentThread().getName()) ;
}
}

}
class MyThread implements Runnable//extends Thread
{
public void run()
{
while(true)
{
System.out.println("run:"+Thread.currentThread().getName()) ;
}
}
}

Demo3:

/* 线程之间的通信是协调线程同步的重要方法 、
* Object类的 wait方法通告同步对象进入等待状态,直到其他线程得到同步对象 并且调用 notity方法 ,等待线程才会继续执行
* notify方法 是通告同步对象的等待线程进入恢复运行
* notifyAll通告所有堵塞线程恢复运行
* 下面是一个生产消费者的问题 ,在对于类的操作的时候 一定要有面向对象的思想 。 否则 就会非常的杂乱
*/
class Producer implements Runnable
{
Q q ;
public Producer(Q q)
{
this.q=q ;
}
public void run()
{
int i=0 ;
while(true)
{
/*synchronized(q)
{
if(q.bFull==true)
try{q.wait() ;}catch(Exception ex){}
if(i==0)
{
q.name="zhangsan" ;
try{
Thread.sleep(1) ;
}catch(Exception ex){}
q.sex="male" ;
}
else
{
q.name="lisi" ;
q.sex="female" ;
}
q.bFull=true ;
q.notify() ;
}
i=(i+1)%2 ;
*/

if(i==0 )
q.push("zhangsan","male");
else
q.push("lisi","female") ;
i=(i+1)%2 ;
}

}
}
class Consumer implements Runnable
{
Q q ;
public Consumer(Q q)
{
this.q=q ;
}
public void run()
{
while(true)
{
/* synchronized(q)
{
if(!q.bFull)
{
try{q.wait() ;}catch(Exception ex){}
}
System.out.println(q.name+":"+q.sex) ;
q.bFull=false ;
q.notify() ;
}
*/
q.get() ;
}
}
}

class Q //以面向对象的思想对线程之间的通信进行封装从而实现消费者 生产社的问题
{
String name="unknown" ;
String sex ="unknown" ;
boolean bFull=false ;
public synchronized void push(String name,String sex)
{
if(this.bFull==true)
try{wait() ;}catch(Exception ex){}
this.name=name ;
this.sex=sex ;
bFull=true ;
try{notify() ;}catch(Exception ex){}
}
public synchronized void get()
{
if(this.bFull==false)
try{wait() ;}catch(Exception ex){}
System.out.println("name:"+this.name+" sex:"+this.sex) ;
bFull=false ;
try{notify() ;}catch(Exception ex){}
}
}

class ThreadTest implements Runnable //这个线程类 来模拟线程的声明结束 因为Thread类的 stop suspend等方法都已经过时了
{ //所以有时候我们对于线程的开始和结束要自己设置标志位来
boolean bRun=true ;
int index=0 ;
public void stopMe()
{
bRun=false ;
}
public void run()
{
while(bRun)
{
if(++index>100)
stopMe() ;
System.out.println(Thread.currentThread().getName()+" is running!");
}

}

}

public class ThreadDemo3
{

public static void main(String[]args)
{

Q q=new Q() ;
new Thread(new Producer(q)).start() ;
new Thread(new Consumer(q)).start() ;

}
}