java多线程实现卖票程序（synchronized）

本文采用java多线程实现了模拟车站多个车票卖票的功能。

关键词：java多线程并发共享资源互斥访问实现runnable接口 volatile 线程同步。

关键：线程同步，因为创建了多个线程，那么卖票部分代码应该上锁来保证线程对此关键代码的互斥访问，上锁的方式有两种，一种是synchronized隐式锁，另一种是Lock.lock()显式锁。

问题1：两种锁的区别:使用显示锁可以做到更细的控制粒度。比如可以设置一个线程试图获取锁，但是设定时间内获取锁失败可以进行其他操作等，这些事synchronized锁无法实现的。

问题2：synchronized作用讲解

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

五、以上规则对其它对象锁同样适用.

代码如下

Ticket类

package ex7_TicketSaler;

/*同一对象的多个线程thread0/1/2，对共享变量count的操作，需要将count的值声明为volatile
 * 并且因为多个线程操作的是同一个对象ticket，因此count是资源共享的
 * 
 */

public class Ticket implements Runnable{
    volatile int count = 1000;   //总共的票数量
    Boolean flag = true;
    Object locObj = new Object();
    @Override
    public void run() {
        // TODO Auto-generated method stub
        //加入同步块后，count的值不会出现错误
            
            while(count>0)
            {
//                synchronized(locObj)
//                {
//                    
//                    
//                    
//                }
                getTicket();
                
                                
            }    
            
            //线程结束后的处理程序
            System.out.println(Thread.currentThread().getName()+"执行结束\n");
        

    }
    
    //定义了一个同步方法  此方法同时只能被一个线程执行完毕后，另一个线程才能够执行
    
    public synchronized void getTicket()
    {
        
        if(count>0)
        {
            count--;
            System.out.println(Thread.currentThread().getName()+"卖出一张票，"+"剩余票数："+count +"\n");
            Thread.yield();    
            
        }
        else
        {
            flag = false;
        }
    }
    
}

对getTicket显式上锁：

    public  void getTicket()
    {
        //显式上锁
        lock.lock();
        try
        {
            if(count>0)
            {
                count--;
                System.out.println(Thread.currentThread().getName()+"卖出一张票，"+"剩余票数："+count +"\n");
                Thread.yield();       //让出线程控制权，如果不加锁的话会很容易出现问题
                
            }
            else
            {
                flag = false;
            }
            
        }finally
        {
            lock.unlock();
        }

        
    }

TicketSaler类

package ex7_TicketSaler;

public class TicketSaler {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("开始售票\n");
        int n = 10;
        Thread [] threads= new Thread[n];
        Ticket ticket = new Ticket();
        for (int i=0;i<n;i++)
        {
            threads[i] = new Thread(ticket);
            threads[i].setName("售票窗口"+i);
            threads[i].start();
        }
//        for(int i=0;i<n;i++)
//        {
//            System.out.println("线程名"+threads[i].getName()+"\n");
//        }
        
        //让新开的新城先执行，控制线程结束
        //thread[0]在thread[1]前执行完毕，thread[1]在thread[2]前执行完毕,thread[2]在主线程之前执行完毕
        for(int i=n-1;i>0;i--)
        {
            try {
                threads[i].join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
        System.out.println("结束售票\n");
        
    }

}

来源：https://www.cnblogs.com/wll-zju/p/4338184.html

标签

synchronized

线程

多线程

线程阻塞

object