java基础整理十二（多线程2）

/*线程间通讯：其实就是多个线程在操作同一个资源，但是操作的动作不同。

实例：双线程一存一取*/
class Pon
{
String name;
String sxe;
boolean flag = false;
}

class TestIn implements Runnable
{
private Pon p;
TestIn(Pon p)
{
this.p = p;
}
public void run()
{
boolean b = true;
while(true)
{
synchronized(p)//寻找共同对象即使用共同锁
{
if (p.flag)
try
{
p.wait();
}
catch (Exception e)
{
}
if (b==true)
{
p.name = "漂亮";
p.sxe = "女人";
b = false;
}
else
{
p.name = "帅气";
p.sxe = "男人";
b = true;
}
p.flag = true;
p.notify();
}
}
}


}
class TestOut implements Runnable
{
private Pon p;
TestOut(Pon p)
{
this.p = p;
}
public void run()
{
while (true)
{
synchronized(p)//寻找共同对象即使用共同锁
{
if (!p.flag)
try
{
p.wait();
}
catch (Exception e)
{
}
System.out.println(p.name+"---"+p.sxe);
p.flag = false;
p.notify();
}
}

}
}
class TestRun
{
public static void main(String[]args)
{
Pon p =new Pon();//创建资源
TestIn in = new TestIn(p);
TestOut out = new TestOut(p);
Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
t1.start();
t2.start();
}
}
wait(); notify();notifyAll();wait()使用时注意要抛或try，它属于异常机制中的一元。都使用在同步中，因为要对持有监视器（锁）的线程操作
所以要使用在同步中，因为只有同步才具有锁。


为什么这些操作线程的方法要定义Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁。
只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒，不可以对不同锁中的线程进行唤醒。
也就是说，等待和唤醒必须是同一个锁，而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。


当存在多个线程如生产者消费者的例子 必须用while循环进行循环判断让被唤醒的线程再一次判断标记。
用notifyAll进行唤醒。因为要唤醒对方线程，只用notify，容易出现只唤醒本方线程的情况导致程序中所有线程都等待。


class ChanXiao
{
public static void main(String[]args)
{
ShuXing s = new ShuXing();
ShengChan sc = new ShengChan(s);
XiaoFei xf = new XiaoFei(s);
Thread t1 = new Thread(sc);
Thread t2 = new Thread(xf);
Thread t3 = new Thread(sc);
Thread t4 = new Thread(xf);
t1.start();
t2.start();
t4.start();
t3.start();
}
}
class ShuXing
{
private String name;
private int count = 1;
private boolean flag = false;
public synchronized void set(String name)
{
while (flag)
try{this.wait();}catch (Exception e){}
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
flag = true;
this.notifyAll();
}


public synchronized void out()
{
while (!flag)
try{this.wait();}catch (Exception e){}
System.out.println(Thread.currentThread().getName()+"--消费者--"+this.name);
flag = false;
this.notifyAll();
}
}
class ShengChan implements Runnable
{
private ShuXing s;
ShengChan(ShuXing s)
{
this.s= s;
}
public void run()
{
while(true)
{
s.set("商品");
}
}
} 
class XiaoFei implements Runnable
{
private ShuXing s;
XiaoFei(ShuXing s)
{
this.s = s;
}
public void run()
{
while(true)
{
s.out();
}
}
}

升级5.0后之后改版：JDK 1.5 中提供了多线程升级解决方案。将同步synchronized替换成Lock操作
将Object中的wait，notify notifyAll，替换成了Condition对象 new Condition().await()，new Condition().signal(), new Condition().signalAll().该对象可以通过Lock锁进行获取。
在该示例中，实现了只唤醒对方的操作。
import java.util.concurrent.locks.*;
class ChanXiao
{
public static void main(String[]args)
{
ShuXing s = new ShuXing();
ShengChan sc = new ShengChan(s);
XiaoFei xf = new XiaoFei(s);
Thread t1 = new Thread(sc);
Thread t2 = new Thread(xf);
Thread t3 = new Thread(sc);
Thread t4 = new Thread(xf);
t1.start();
t2.start();
t4.start();
t3.start();
}
}
class ShuXing
{
private String name;
private int count = 1;
private boolean flag = false;
private Lock lock = new ReentrantLock();//重点位置
private Condition condition_sc = lock.newCondition();
private Condition condition_xf = lock.newCondition();
public void set(String name)throws InterruptedException
{
lock.lock();
try
{
while (flag)
condition_sc.await();//抛异常
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
flag = true;
condition_xf.signal();
}
finally
{
lock.unlock();
}
}


public void out()throws InterruptedException
{
lock.lock();
try
{
while (!flag)
condition_xf.await();
System.out.println(Thread.currentThread().getName()+"--消费者--"+this.name);
flag = false;
condition_sc.signal();
}
finally
{
lock.unlock();
}

}
}
class ShengChan implements Runnable
{
private ShuXing s;
ShengChan(ShuXing s)
{
this.s= s;
}
public void run()
{
while(true)
{
try
{
s.set("商品");
}
catch (InterruptedException e)
{
}

}
}
} 
class XiaoFei implements Runnable
{
private ShuXing s;
XiaoFei(ShuXing s)
{
this.s = s;
}
public void run()
{
while(true)
{
try
{
s.out();
}
catch (InterruptedException e)
{
}

}
}
}


stop方法已过时，如何停止线程？只有一种，run方法结束。了开启多线程运行，运行代码通常是循环结构。
只要控制住循环，就可以让run方法结束，也就是线程结束。


特殊情况：当线程处于了冻结状态，就不会读取到标记，那么线程就不会结束。
当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。强制让线程恢复到运行状态中来。
这样就可操作标记让线程结束。
Thread类提供该方法interrupt();


class StopThread implements Runnable
{
private boolean flag  = true;
public synchronized void run()
{
while (flag)
{
try
{
wait();
}
catch (InterruptedException e)
{
System.out.println(Thread.currentThread().getName()+"...Exception");
flag = false;
}
System.out.println(Thread.currentThread().getName()+"...run");
}
}
}
class StopThreadDemo
{
public static void main(String[]args)
{
StopThread st = new StopThread();
Thread t1 = new Thread(st);
Thread t2 = new Thread(st);
t1.start();
t2.start();
int num = 0;
while (true)
{
if (num++ == 90)
{
t1.interrupt();
t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName()+"..."+num);
}
System.out.println("over");
}
}


t1.setDaemon(true)标记t1为守护线程。
setDaemon()守护线程可随前台线程结束而结束 当正在运行的线程都是守护线程时，Java虚拟机退出。该方法必须在启动线程前调用
所以前台线程结束后 后台线程自动结束。

join等待终止线程 t1.join();t1申请加入运行中来，即获取cup执行权。执行结束后才释放执行权。
join特点：当A线程执行到了B线程的.join()方法时，A就会等待，等B线程都执行完，A才会执行。
join可以用来临时加入线程执行。


class Demo implements Runnable
{
public void run()
{
for (int x=0;x<70 ;x++ )
{
System.out.println(Thread.currentThread().getName()+"--"+x);
}
}
}
class JoinDemo
{
public static void main(String[]args)throws Exception
{
Demo d = new Demo();
Thread t1 =new Thread(d);
Thread t2 =new Thread(d);
t1.start();
t1.join();
t2.start();
for (int x=0;x<80 ;x++ )
{
System.out.println("maim---"+x);
}
System.out.println("over");
}
}


toString();包括线程名称，优先级，线程组。默认优先级为5。setPriority()设置优先级 分为最高MAX_PRIORITY 最低MIN_PRIORITY 默认NORM_PRIORITY
例t1.setPriority(Thread.MAX_PRIORITY);设置t1优先级为最高10级。
yield()暂停当前正在执行的线程对象，并执行其他线程。


建立线程实例：
class ThreadTest
{
public static void main(String[]args)
{
new Thread()
{
public void run()
{
for (int x=0;x<100 ;x++ )
{
System.out.println(Thread.currentThread().getName()+"---"+x);
}
}
}.start();


for (int x=0;x<100 ;x++ )
{
System.out.println(Thread.currentThread().getName()+"---"+x);
}


Runnable r = new Runnable()
{
public void run()
{
for (int x=0;x<100 ;x++ )
{
System.out.println(Thread.currentThread().getName()+"---"+x);
}
}
};
new Thread(r).start();
}

}