java多线程--12

于 2015-08-02 13:09:18 发布
阅读量288 收藏
点赞数
分类专栏： java 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java19930623/article/details/47184019
版权

线程间通讯

其实就是多个线程在操作同一个资源，但是操作的动作不同

notifyAll();

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)
        {
            synchronized(r)
            {
                if(r.flag)
                    try{r.wait();}catch(Exception e){}
                if(x==0)
                {
                    r.name = "mike";
                    r.sex = "man";
                }
                else
                {
                    r.name = "丽丽";
                    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+"....."+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(name+"..."+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("mike","man");
            else
                r.set("丽丽","女女女");
            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 InputOutputDemo2
{
    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(pro);
        Thread t3 = new Thread(con);
        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;


    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{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判断标记
原因：让被唤醒的线程再一次判断标记

为什么定义notifyAll
因为需要唤醒对方线程
因为只用notify，容易出现只唤醒本方线程的情况，导致程序中所有的线程都等待

Lock替代Synchronized

import java.util.concurrent.locks.*;

class ProducerConsumerDemo2
{
    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(pro);
        Thread t3 = new Thread(con);
        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)
            {

            }
        }
    }
}

这里写图片描述

JDK1.5 中提供了多线程升级解决方法
将同步Synchronized替换成现实Lock操作
将Object中的wait，notify notifyAll，替换成了Condition对象
该对象可以Lock锁 进行获取
该实例中，，实现了本方只唤醒对方的操作

停止线程

如何停止线程？
只有一种，run方法结束
开启多线程运行，运行代码通常是循环结构

只要控制住循环，就可以让run方法结束，也就是线程结束

class StopThread implements Runnable
{
    private boolean flag = true;
    public void run()
    {
        while(flag )
        {
            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();
                break;
            }
            System.out.println(Thread.currentThread().getName()+"....."+num);
        }   

      }
}

这里写图片描述

stop()已经过时了。不再使用。

特殊情况：
当线程处于了冻结状态，
就不会读取到标记。那么线程就不会结束

当没有指定的方式让冻结的线程恢复到运行状态时：这时需要对冻结进行清除
强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。
Thread类中提供了该方法：Interrupt()
Interrupt()：中断线程，强制让线程恢复到运行状态上来。会发生InterruptedException，一定要记得处理。

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");
        }
    }
    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("over");
    }
}

这里写图片描述

setDaemon 守护线程
当运行的线程都是守护线程时，java虚拟机退出
该方法必须在启动线程前调用。

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");
        }
    }
    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.setDaemon(true);
        t2.setDaemon(true);
        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("over");
    }
}

这里写图片描述

join

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();

        t2.start();
        t1.join();


        for(int x=0;x<80;x++)
        {
            System.out.println("main....."+x);
        }
        System.out.println("over");
    }
}

这里写图片描述

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


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


        //线程3
        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();

        //new Test1().start();
    }

}
/*
class Test1 extends Thread
{
    public void run()
    {
        for(int x=0;x<100;x++)
        {
            System.out.println(Thread.currentThread().getName()+"...."+x);
        }
    }
}
*/
飞鸿踏雪泥-
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值