线程——线程同步

案例:卖票

需求:某电影院目前正在上映国产大片,共有100张票,而它有三个窗口卖票,请设计一个程序模拟该电影院卖票

思路:

        定义一个类SellTicket实现Runnable接口,里面定义一个成员变量:private in tickets = 100;

        在SellTicket类中重写run()方法实现卖票,代码步骤如下

                判断票数大于0,就卖票,并告知是那个窗口卖的

                卖了票之后,总票数减1

                票没了,也可能有人来问,所以这里用死循环让卖票的动作一直执行

定义一个测试类SellTicketDemo,里面有main()方法,代码步骤如下

                创建SellTicket类对象

                创建三个Thread类的对象,把SellTicket对象作为构造方法的参数,并给出对应的窗口名称

                启动线程

package com.aynu14;

//定义一个类SellTicket实现Runnable接口,里面定义一个成员变量:private in tickets = 100;
public class SellTicket implements Runnable{
    private int tickets=100;
    
    //在SellTicket类中重写run()方法实现卖票,代码步骤如下

    @Override
    public void run() {
//            判断票数大于0,就卖票,并告知是那个窗口卖的
//            卖了票之后,总票数减1
//            票没了,也可能有人来问,所以这里用死循环让卖票的动作一直执行
        while (true){
        if (tickets>0) {
            System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
            tickets--;
            
            }
        }
    }
}
package com.aynu14;

//    需求:某电影院目前正在上映国产大片,共有100张票,而它有三个窗口卖票,请设计一个程序模拟该电影院卖票
//
//        思路:
//        定义一个类SellTicket实现Runnable接口,里面定义一个成员变量:private in tickets = 100;
//        在SellTicket类中重写run()方法实现卖票,代码步骤如下
//            判断票数大于0,就卖票,并告知是那个窗口卖的
//            卖了票之后,总票数减1
//            票没了,也可能有人来问,所以这里用死循环让卖票的动作一直执行
//
//        定义一个测试类SellTicketDemo,里面有main()方法,代码步骤如下
//            创建SellTicket类对象
//            创建三个Thread类的对象,把SellTicket对象作为构造方法的参数,并给出对应的窗口名称
//            启动线程

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

        //创建SellTicket类对象
        SellTicket st=new SellTicket();

        //创建三个Thread类的对象,把SellTicket对象作为构造方法的参数,并给出对应的窗口名称
        Thread t1=new Thread(st,"窗口1");
        Thread t2=new Thread(st,"窗口2");
        Thread t3=new Thread(st,"窗口3");

        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

 卖票出现了问题

        相同的票出现多次

        出现了负数的票

问题原因

        线程执行的随机性导致的

卖票案例数据安全问题的解决

        为什么出现问题?(这也是我们判断多线程程序是否会有数据安全问题的标准)

                是否具有多线程环境

                是否有共享数据

                是否有多条语句操作共享数据

如何解决多线程安全问题

        基本思想:让程序没有安全问题的环境

怎么实现呢?

        把多条语句操作共享数据的代码锁起来,让任意时刻只能有一个线程执行即可

        java提供了同步代码块的方式来解决

锁多条语句操作共享数据,可以使用同步代码块实现

格式:

        synchronized(任意对象){

                多条语句操作共享数据的代码

}

synchronized(任意对象):就相当于给代码加锁了,任意对象就可以看成是一把锁

同步的好处和弊端

        好处:解决了多线程的数据安全问题

        弊端:当线程很多时,因为每个线程都会去判断同步上的锁,这里很耗费资源的,无形中会降低程序的运行效率

package com.aynu14;

//定义一个类SellTicket实现Runnable接口,里面定义一个成员变量:private in tickets = 100;
public class SellTicket implements Runnable{
    private int tickets=100;
    private Object obj=new Object();

    //在SellTicket类中重写run()方法实现卖票,代码步骤如下

    @Override
    public void run() {
//            判断票数大于0,就卖票,并告知是那个窗口卖的
//            卖了票之后,总票数减1
//            票没了,也可能有人来问,所以这里用死循环让卖票的动作一直执行
        //相同票出现了多次
//        while (true){
//            //tickest=100;
//            //t1,t2,t3
//            //假设t1线程抢到CPU执行权
//        if (tickets>0) {
//            //通过Sellp()方法来模拟出票时间
//            try {
//                Thread.sleep(100);
//                //t1线程休息100毫秒
//                //t2线程抢到CPU的执行权,t2线程就开始执行,执行到这里的时候,t2线程休息100毫秒
//                //t3线程抢到CPU的执行权,t3线程就开始执行,执行到这里的时候,t3线程休息100毫秒
//            } catch (InterruptedException e) {
//                throw new RuntimeException(e);
//            }
//            //假设线程按照顺序醒过来
//            //t1抢到CPU的执行权,在控制台输出,窗口1正在出售第100张票
//            System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
//            //t2抢到CPU的执行权,在控制台输出,窗口2正在出售第100张票
//            //t3抢到CPU的执行权,在控制台输出,窗口3正在出售第100张票
//            tickets--;
//
//            //如果这三个线程还是按照顺序来,这里就执行了3次--操作,最终票就变成了97
//            }
//        }


        //出现了负数的票
        while (true){
            synchronized (obj) {
                //tickest=1;
                //t1,t2,t3
                //假设t1线程抢到CPU执行权
                if (tickets > 0) {
                    //通过Sellp()方法来模拟出票时间
                    try {
                        Thread.sleep(100);
                        //t1线程休息100毫秒
                        //t2线程抢到CPU的执行权,t2线程就开始执行,执行到这里的时候,t2线程休息100毫秒
                        //t3线程抢到CPU的执行权,t3线程就开始执行,执行到这里的时候,t3线程休息100毫秒
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    //假设线程按照顺序醒过来
                    //t1抢到CPU执行权,在控制台输出,窗口1正在出售第1张票
                    //假设t1继续拥有CPU的执行权,就会执行tickets--操作,ticket=0;
                    //t2抢到CPU执行权,在控制台输出,窗口2正在出售第0张票
                    //假设t2继续拥有CPU的执行权,就会执行tickets--操作,ticket=-1;
                    //t3抢到CPU执行权,在控制台输出,窗口2正在出售第-1张票
                    //假设t3继续拥有CPU的执行权,就会执行tickets--操作,ticket=-2;
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--;

                }
            }
        }
    }
}
package com.aynu14;

//    需求:某电影院目前正在上映国产大片,共有100张票,而它有三个窗口卖票,请设计一个程序模拟该电影院卖票
//
//        思路:
//        定义一个类SellTicket实现Runnable接口,里面定义一个成员变量:private in tickets = 100;
//        在SellTicket类中重写run()方法实现卖票,代码步骤如下
//            判断票数大于0,就卖票,并告知是那个窗口卖的
//            卖了票之后,总票数减1
//            票没了,也可能有人来问,所以这里用死循环让卖票的动作一直执行
//
//        定义一个测试类SellTicketDemo,里面有main()方法,代码步骤如下
//            创建SellTicket类对象
//            创建三个Thread类的对象,把SellTicket对象作为构造方法的参数,并给出对应的窗口名称
//            启动线程

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

        //创建SellTicket类对象
        SellTicket st=new SellTicket();

        //创建三个Thread类的对象,把SellTicket对象作为构造方法的参数,并给出对应的窗口名称
        Thread t1=new Thread(st,"窗口1");
        Thread t2=new Thread(st,"窗口2");
        Thread t3=new Thread(st,"窗口3");

        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

同步方法:就是把synchronized关键字加到方法上

        格式:

        修饰符synchronized返回值类型 方法名(方法参数){ }

同步方法的锁对象是什么呢

        this

同步静态方法,就是把synchornized关键字加到静态方法上

        格式

        修饰符static synchronized返回值类型 方法名(方法参数)

同步静态方法的锁对象是什么呢

        类名.class

你可能感兴趣的:(java,学习)