java多进程 -CD7-孙鑫-(4)-同步方法，同步块，售票例子

最新推荐文章于 2020-05-27 19:30:38 发布

阳光西西

最新推荐文章于 2020-05-27 19:30:38 发布

阅读量669

点赞数

分类专栏：孙鑫-java基础文章标签： runnable 接口同步 java

本文链接：https://blog.csdn.net/u013225534/article/details/44888075

版权

孙鑫-java基础专栏收录该内容

17 篇文章 0 订阅

订阅专栏

本节主要包含使用内部类来实现与使用Runnable接口实现线程一样的效果，还包含一个小例子售票来引出同步机制：同步块和同步方法

使用实现Runnable方法好处有两条：

如果你的MyThread类已经继承了一个类，那么java中不允许多继承，这样让你的MyThread实现一个Runnable接口正好啊。
如果同一个对象创建多线程那么共享一个数据成员index

使用内部类同样可以实现使用Runnable的两条好处

class MultiThread
{
    public static void main(String[] args)
    {
        MyThread myThread = new MyThread();
        //如果创建多个线程但是是同一个对象，那么他们共享一个index
        //new Thread(myThread).start();
        //new Thread(myThread).start();
        //new Thread(myThread).start();
        //new Thread(myThread).start();
        //new Thread(myThread).start();
        myThread.getThread().start();
        myThread.getThread().start();
        myThread.getThread().start();
        myThread.getThread().start();
        //设置为后台线程
        //myThread.setDaemon(true);
        //设置优先级
        //myThread.setPriority(Thread.MAX_PRIORITY);
        //myThread.start();
        //int index = 1;
        while(true)
        {
                //if(index++ == 1000)
                //break;
                //获取当前的线程并且获取它的名字
            System.out.println("main方法所在的线程的名字：" + Thread.currentThread().getName());   
        }
    }
}
class MyThread //implements Runnable//extends Thread
{
    int index = 0;
    class InnerThread extends Thread
    {   
        public void run()
        {
            while(true)
            {
            //内部类可以访问外部类的成员
            System.out.println(Thread.currentThread().getName() + ":" + index++);   
            //将当前线程暂停
            //yield();
            }   
        }
    } 
    //隐藏实现细节
    Thread getThread()
    {
        return new InnerThread();
    }
    //run方法是线程的入口函数
    /*public void run()
    {
        while(true)
        {

            System.out.println(Thread.currentThread().getName() + ":" + index++);   
            //将当前线程暂停
            //yield();
        }   
    }*/ 
}

联系模拟火车票售票系统
public static void sleep (long millis, int nanos)
线程的同步
The code segments within a program that access the same object from separate, concurrent threads are called “critical sections”。
在一个程序当中代码段访问了同一个对象从单独的并发的线程当中，那么这个代码段叫”临界区”
使用同步的机制对临界区进行保护

同步的两种方式：同步块和同步方法
对于同步来说都是使用synchronized方法

每一个对象都有一个监视器，或者叫做锁。
同步块示例

//C:\Users\Administrator\Documents\GitHub
package ticket;

class Tickets {
    public static void main(String[] args)
    {
        sellTickets st = new sellTickets();
        //四个线程同时卖这100张票，注意是同一个对象创建四个线程，他们共享同一个变量ticket
        new Thread(st).start();
        new Thread(st).start();
        new Thread(st).start();
        new Thread(st).start();
    }
}
class sellTickets implements Runnable
{
    int ticket = 100;
    Object o = new Object();
    @Override
    public void run() {
        while(true)
        {
            //每一个对象都有一个监视器，或者叫做锁。同步块示例
            synchronized (o) {
                if(ticket > 0)
                {
                    //存在的隐藏的问题当ticket=1，它的时间片到期了进入到if语句中，第二个线程进入到if语句然后时间片到期
                    try {
                        //线程睡眠,该方法需要写异常
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();                    
                    }
                    //第几个线程卖出了第多少张票
                    System.out.println(Thread.currentThread().getName() + "sell tickets" + ticket);
                    ticket--;
                }
            }
        }
    }
}

同步方法示例

//C:\Users\Administrator\Documents\GitHub
package ticket;

class Tickets {
    public static void main(String[] args)
    {
        sellTickets st = new sellTickets();
        //四个线程同时卖这100张票，注意是同一个对象创建四个线程，他们共享同一个变量ticket
        new Thread(st).start();
        new Thread(st).start();
        new Thread(st).start();
        new Thread(st).start();
    }
}
class sellTickets implements Runnable
{
    int ticket = 100;
    Object o = new Object();
    @Override
    public void run() {
        while(true)
        {
            sell();
        }
    }
    public synchronized void sell()
    {
        if(ticket > 0)
        {
            //存在的隐藏的问题当ticket=1，它的时间片到期了进入到if语句中，第二个线程进入到if语句然后时间片到期
            try {
                //线程睡眠,该方法需要写异常
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();                    
            }
            //第几个线程卖出了第多少张票
            System.out.println(Thread.currentThread().getName() + "sell tickets" + ticket);
            ticket--;
        }
    }
}

同步方法利用的是this所代表的对象加的锁。

示例：分别使用同步块和同步方法来实现正确的结果
当同步块利用this所代表的对象synchronized (this)时就和同步方法使用的锁一致了

//C:\Users\Administrator\Documents\GitHub
package ticket;

class Tickets {
    public static void main(String[] args) {

        sellTickets st = new sellTickets();
        // 四个线程同时卖这100张票，注意是同一个对象创建四个线程，他们共享同一个变量ticket
        new Thread(st).start();
        //为什么写sleep因为当我们main时间片没有消耗完，不会执行new Thread(st).start()（第一个）那么st.b = true;赋值执行了并且赋值成功，当main 时间片消耗完再来执行new Thread(st).start()（第一个），此时已经是为false了，所以写sleep 是为了让主线程睡一会
        try{
            Thread.sleep(1);
        }catch(Exception e){
            e.printStackTrace();
        }
        st.b = true;
        new Thread(st).start();
    }
}

class sellTickets implements Runnable {
    int ticket = 100;
    Object o = new Object();
    //定义一个boolean变量让同步块和同步方法分别执行
    public boolean b = false;

    @Override
    public void run() {
            if (b == false) {
                while (ticket > 0) {
                    try {
                        // 线程睡眠,该方法需要写异常
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //false时执行同步方法
                    sell();
                }
            } else {
                //当true时执行同步块
                while (ticket > 0) {
                    try {
                        // 线程睡眠,该方法需要写异常
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (this) {
                        if(ticket > 0){
                            // 第几个线程卖出了第多少张票
                            System.out.println("obj"
                                    + Thread.currentThread().getName()
                                    + "sell tickets" + ticket);
                            ticket--;
                        }
                    }
                }
            }
        }

    public synchronized void sell() {
        if(ticket > 0){
            // 第几个线程卖出了第多少票号的张票
            System.out.println("sell:" + Thread.currentThread().getName()
                    + "sell tickets" + ticket);
            ticket--;
        }
    }
}

结果：
sell:Thread-0sell tickets10
objThread-1sell tickets9
sell:Thread-0sell tickets8
objThread-1sell tickets7
sell:Thread-0sell tickets6
objThread-1sell tickets5
sell:Thread-0sell tickets4
objThread-1sell tickets3
sell:Thread-0sell tickets2
objThread-1sell tickets1
下节预告
每个class也有一个锁，是这个class所对应的Class对象的锁。