一、多线程(线程间通信-示例代码)
- /*
- 线程间通讯:
- 其实就是多个线程在操作同一个资源,但是操作的动作不同。
- */
- class Res
- {
- String name;
- String sex;
- }
- class Input implements Runnable
- {
- private Res r;
- Input(Res r)
- {
- this.r=r;
- }
- public void run()
- {
- int x=0;
- while(true)
- {
- if(x==0)
- {
- r.name="mike";
- r.sex="男";
- }
- else
- {
- r.name="lili";
- r.sex="女";
- }
- x=(x+1)%2;
- }
- }
- }
- class Output implements Runnable
- {
- private Res r;
- Output(Res r)
- {
- this.r=r;
- }
- public void run()
- {
- while(true)
- {
- System.out.println("姓名:"+r.name+"\t"+"性别:"+r.sex);
- }
- }
- }
- class InputOutputDemo
- {
- public static void main(String[] args)
- {
- Res r=new Res();
- Input in=new Input(r);
- Output out=new Output(r);
- Thread t1=new Thread(in);
- Thread t2=new Thread(out);
- t1.start();
- t2.start();
- }
- }
二、多线程(线程间通信-解决安全问题)
- /*
- 线程间通讯:
- 其实就是多个线程在操作同一个资源,但是操作的动作不同。
- */
- class Res
- {
- String name;
- String sex;
- }
- class Input implements Runnable
- {
- private Res r;
- Input(Res r)
- {
- this.r=r;
- }
- public void run()
- {
- int x=0;
- while(true)
- {
- synchronized(r)//Input.class也可以
- {
- if(x==0)
- {
- r.name="mike";
- r.sex="男";
- }
- else
- {
- r.name="lili";
- r.sex="女";
- }
- x=(x+1)%2;
- }
- }
- }
- }
- class Output implements Runnable
- {
- private Res r;
- Output(Res r)
- {
- this.r=r;
- }
- public void run()
- {
- while(true)
- {
- synchronized(r)
- {
- System.out.println("姓名:"+r.name+"\t"+"性别:"+r.sex);
- }
- }
- }
- }
- class InputOutputDemo
- {
- public static void main(String[] args)
- {
- Res r=new Res();
- Input in=new Input(r);
- Output out=new Output(r);
- Thread t1=new Thread(in);
- Thread t2=new Thread(out);
- t1.start();
- t2.start();
- }
- }
三、多线程(线程间通信-等待唤醒机制)
wait():
notify():
notifyAll():
都使用在同步中,因为要对持有监视器(锁)的线程操作。所以要使用在同步中,因为只有同步才具有锁。
为什么这些操作线程的方法要定义在Object类中呢?
因为这些方法在操作同步中线程时,都必须要表示它们所操作线程只有的锁,只有同一个锁上的被等待线程,才可以被同一个上notify唤醒。也就是说等待和唤醒必须是同一个锁。
而锁可以是任意对象,所以可以被任意对象调用的方法定义Object类中。
- /*
- 线程间通讯:
- 其实就是多个线程在操作同一个资源,但是操作的动作不同。
- */
- class Res
- {
- String name;
- String sex;
- boolean flag=false;
- }
- class Input implements Runnable
- {
- private Res r;
- Input(Res r)
- {
- this.r=r;
- }
- public void run()
- {
- int x=0;
- while(true)
- {
- if(r.flag)
- try{r.wait();}catch(Exception e){}//存入线程池中
- synchronized(r)//Input.class也可以
- {
- if(x==0)
- {
- r.name="mike";
- r.sex="男";
- }
- else
- {
- r.name="lili";
- r.sex="女";
- }
- x=(x+1)%2;
- r.flag=true;
- r.notify();//唤醒线程池中的线程。(第一个存放的,例如队列)
- }
- }
- }
- }
- class Output implements Runnable
- {
- private Res r;
- Output(Res r)
- {
- this.r=r;
- }
- public void run()
- {
- while(true)
- {
- synchronized(r)
- {
- if(!r.flag)
- try{r.wait();}catch(Exception e){}//存入线程池中
- System.out.println("姓名:"+r.name+"\t"+"性别:"+r.sex);
- r.flag=false;
- r.notify();//唤醒线程池中的线程。(第一个存放的,例如队列)
- }
- }
- }
- }
- class InputOutputDemo
- {
- public static void main(String[] args)
- {
- Res r=new Res();
- Input in=new Input(r);
- Output out=new Output(r);
- Thread t1=new Thread(in);
- Thread t2=new Thread(out);
- t1.start();
- t2.start();
- }
- }
四、多线程(线程间通信-代码优化)
- /*
- 优化:
- */
- class Res
- {
- private String name;
- private String sex;
- private boolean flag=false;
- public synchronized void set(String name,String sex)
- {
- if(flag)
- try{this.wait();}catch(Exception e){}//存入线程池中
- this.name=name;
- this.sex=sex;
- flag=true;
- this.notify();
- }
- public synchronized void out()
- {
- if(!flag)
- try{this.wait();}catch(Exception e){}//存入线程池中
- System.out.println("姓名:"+this.name+"\t"+"性别:"+this.sex);
- flag=false;
- this.notify();//唤醒线程池中的线程。(第一个存放的,例如队列)
- }
- }
- class Input implements Runnable
- {
- private Res r;
- Input(Res r)
- {
- this.r=r;
- }
- public void run()
- {
- int x=0;
- while(true)
- {
- if(x==0)
- {
- r.set("maike","男");
- }
- else
- {
- r.set("lili","女");
- }
- x=(x+1)%2;
- }
- }
- }
- class Output implements Runnable
- {
- private Res r;
- Output(Res r)
- {
- this.r=r;
- }
- public void run()
- {
- while(true)
- {
- r.out();
- }
- }
- }
- class InputOutputDemo
- {
- public static void main(String[] args)
- { Res r=new Res();
- new Thread(new Input(r)).start();
- new Thread(new Output(r)).start();
- }
- }
五、多线程(线程间通信-生产者消费者)
- /*
- 生产者消费者:
- */
- class ProducerConsumerDemo
- {
- public static void main(String[] args)
- {
- Resource r=new Resource();
- Producer pro=new Producer(r);
- Consumer con=new Consumer(r);
- Thread t1=new Thread(pro);
- Thread t2=new Thread(con);
- t1.start();
- t2.start();
- }
- }
- class Resource
- {
- 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 Producer implements Runnable
- {
- private Resource res;
- Producer(Resource res)
- {
- this.res=res;
- }
- public void run()
- {
- while(true)
- {
- res.set("+商品+");
- }
- }
- }
- class Consumer implements Runnable
- {
- private Resource res;
- Consumer(Resource res)
- {
- this.res=res;
- }
- public void run()
- {
- while(true)
- {
- res.out();
- }
- }
- }
说明:
对于多个生产者和消费者,为什么要定义while判断标记?
原因:让被唤醒的线程再一次判断标记。
为什么定义notityAll ?
因为需要唤醒对方线程,只用notify容易唤醒本方线程的情况,导致程序中的所有线程都等待。
六、多线程(线程间通信-生产者消费者JDK5.0升级版)
- /*
- JDK1.5中提供了多线程升级解决方案。(显式锁机制)
- 将同步Synchronized替换成实现Lock操作。
- 将Object中的wait,notify,notifyAll替换成Condition对象。
- 该对象可以通过Lock锁的newCondition()进行获取。
- 在该示例中,实现了本方只唤醒对方的操作。
- */
- import java.util.concurrent.locks.*;
- class ProducerConsumerDemo
- {
- public static void main(String[] args)
- {
- Resource r=new Resource();
- Producer pro=new Producer(r);
- Consumer con=new Consumer(r);
- Thread t1=new Thread(pro);
- Thread t2=new Thread(con);
- Thread t3=new Thread(pro);
- Thread t4=new Thread(con);
- t1.start();
- t2.start();
- t3.start();
- t4.start();
- }
- }
- class Resource
- {
- private String name;
- private int count=1;
- private boolean flag=false;
- private Lock lock=new ReentrantLock();
- private Condition condition_pro=lock.newCondition();//生产
- private Condition condition_con=lock.newCondition();//消费
- public void set(String name)throws InterruptedException
- {
- lock.lock();//加锁
- try
- {
- while(flag)
- condition_pro.await();//挂起线程
- this.name=name+"--"+count++;
- System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
- flag=true;
- condition_con.signal();//唤醒线程
- }
- finally
- {
- lock.unlock();//释放锁的动作一定要执行。
- }
- }
- public void out()throws InterruptedException
- {
- lock.lock();
- try
- {
- while(!flag)
- condition_con.await();
- System.out.println(Thread.currentThread().getName()+"...消费者..........."+this.name);
- flag=false;
- condition_pro.signal();
- }
- finally
- {
- lock.unlock();
- }
- }
- }
- class Producer implements Runnable
- {
- private Resource res;
- Producer(Resource res)
- {
- this.res=res;
- }
- public void run()
- {
- while(true)
- {
- try
- {
- res.set("+商品+");
- }
- catch (InterruptedException e)
- {
- }
- }
- }
- }
- class Consumer implements Runnable
- {
- private Resource res;
- Consumer(Resource res)
- {
- this.res=res;
- }
- public void run()
- {
- while(true)
- {
- try
- {
- res.out();
- }
- catch (InterruptedException e)
- {
- }
- }
- }
- }
七、多线程(停止线程)
- /*
- stop 方法已经过时,如何停止进程?
- 只有一种,run方法结束。
- 开启多线程运行,运行代码通常都是循环结构,只要控制住循环,就可以
- 让run方法结束,也就是线程结束。
- 特殊情况:
- 当线程处于冻结状态,就不会读取到标记,那么线程就不会结束。
- 当没有指定的方式让冻结的线程恢复到运行状态时,这时就需要对冻结进行清除,
- 强制让线程回复到运行状态中来,这样就可以操作标记,让线程结束。
- Thread类中提供了该方法interrupt();
- */
- class StopThread implements Runnable
- {
- private boolean flag=true;
- public synchronized void run()
- {
- while(flag)
- {
- try
- {
- this.wait();
- }
- catch (InterruptedException e)
- {
- System.out.println(Thread.currentThread().getName()+"....Exception");
- flag=false;
- }
- System.out.println(Thread.currentThread().getName()+"....run");
- }
- }
- public void changeFlag()
- {
- flag=false;
- }
- }
- 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++==60)
- {
- //st.changeFlag();
- t1.interrupt();
- t2.interrupt();
- break;
- }
- System.out.println(Thread.currentThread().getName()+"....."+num);
- }
- System.out.println("结束");
- }
- }
八、多线程(守护线程)
public final void setDaemon(boolean on)将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时,Java 虚拟机退出。
该方法必须在启动线程前调用。
该方法首先调用该线程的 checkAccess 方法,且不带任何参数。这可能抛出 SecurityException(在当前线程中)。
参数:
on - 如果为 true,则将该线程标记为守护线程。
一句话总结:守护线程类似于保镖,“保护”其它非守护线程,一旦非守护线程结束,这个“保镖”也就没有存在的意义,所以会守护线程在这时也会结束。
九、多线程(Join方法)
public final void join()
throws InterruptedException
等待该线程终止。
抛出:
InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时,当前线程的中断状态 被清除。
当A线程执行到了B线程的join方法时,A线程就会等待B线程都执行完,A才会执行。
所以,join可以用来临时加入线程的执行。
- /*
- join:
- */
- class Demo implements Runnable
- {
- public void run()
- {
- for(int i=0;i<70;i++)
- {
- System.out.println(Thread.currentThread().getName()+"..."+i);
- }
- }
- }
- 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 i=0;i<80;i++)
- {
- System.out.println("main..."+i);
- }
- System.out.println("结束");
- }
- }
十、多线程(优先级和yield方法)
优先级:线程被执行的优先级别。
public final void setPriority(int newPriority)更改线程的优先级。
首先调用线程的 checkAccess 方法,且不带任何参数。这可能抛出 SecurityException。
在其他情况下,线程优先级被设定为指定的 newPriority 和该线程的线程组的最大允许优先级相比较小的一个。
参数:
newPriority - 要为线程设定的优先级
抛出:
IllegalArgumentException - 如果优先级不在 MIN_PRIORITY 到 MAX_PRIORITY 范围内。
SecurityException - 如果当前线程无法修改该线程。
yield方法:
public static void yield()暂停当前正在执行的线程对象,并执行其它线程。
- /*
- 多线程的应用:
- */
- class ThreadTest
- {
- public static void main(String[] args)
- {
- new Thread()
- {
- public void run()
- {
- for(int i=0;i<100;i++)
- {
- System.out.println(Thread.currentThread().getName()+"..."+i);
- }
- }
- }.start();
- for(int i=0;i<100;i++)
- {
- System.out.println(Thread.currentThread().getName()+"..."+i);
- }
- new Thread(new Runnable()
- {
- public void run()
- {
- for(int i=0;i<100;i++)
- {
- System.out.println(Thread.currentThread().getName()+"..."+i);
- }
- }
- }).start();
- }
- }