多线程

多线程 一、卖票问题

问题描述：某电影院目前正在 上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

思路：

1) 定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;

2) 在SellTicket类中重写rUn0方法实现卖票，代码步骤如下

        A：判断票数大于0，就卖票，并告知是哪个窗口卖的

        B：卖了票之后，总票数要减1

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

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

        A：创建SellTicket类的对象

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

        C：启动线程

public class SellTicket implements Runnable{
    private int tickets=100;
    @Override
    public void run() {
            while (true){
                if(tickets>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+"正在出售第"+tickets+"张票");
                    tickets--;
                }
            }
    }
}

//实现类
public class SellTicket_Demo {
    public static void main(String[] args) {
        SellTicket st=new 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();
    }

}

买票出现了问题：

1）相同的票出现了多次

2）出现了负数的票

窗口1:正在出售第100张票
窗口3:正在出售第100张票
窗口2:正在出售第100张票
窗口2:正在出售第97张票
窗口3:正在出售第97张票
窗口1:正在出售第95张票
窗口2:正在出售第94张票
窗口3:正在出售第93张票
窗口1:正在出售第93张票
窗口3:正在出售第91张票
窗口2:正在出售第91张票

.

.
窗口2:正在出售第6张票
窗口1:正在出售第6张票
窗口3:正在出售第4张票
窗口2:正在出售第3张票
窗口1:正在出售第3张票
窗口3:正在出售第1张票
窗口2:正在出售第0张票
窗口1:正在出售第-1张票

二、卖票问题数据安全问题

判断多线程程序是否会有数据安全问题的标准（三条同时满足，会出现数据安全问题）：

1）是否是多线程环境

2）是否有共享数据

3）是否有多条语句 *** 作共享数据

解决方法：基本思想：破环上述三条其中之一，对第三条进行 *** 作

如何实现：把多条语句 *** 作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可（用同步代码块的方法实现）

同步代码块（三种方法:同步代码块,同步方法,Lock锁）

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

格式：

synchronized(任意对象)

{

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

}

synchronized(任意对象）：就相当于给代码加锁了，任意对象就可以看成是一把锁

public class SellTicket implements Runnable{
    private int tickets=100;
    private Object obj=new Object();
    @Override
    public void run() {
        while (true){
            //同步代码块
            synchronized (obj){
                if(tickets>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+"正在出售第"+tickets+"张票");
                    tickets--;
                }
            }
        }
    }
}

一、同步方法

1）同步方法：就是把synchronized关键字加到方法上

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

同步方法的锁对象：this;

@Override
    public void run() {
        while (true){
            //同步代码块
            if(x%2==0){
              synchronized (this) {//对应同步方法的锁对象
                        if (tickets > 0) {
                             try {
                                Thread.sleep(100);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            System.out.println(Thread.currentThread().getName() + ":" + "正在出售第" + tickets + "张票");
                            tickets--;
                            }
                    }
                }else{
                    sellTicket();
                }
                x++;
            }
        }

//同步方法
private synchronized void sellTicket() {

            if (tickets > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ":" + "正在出售第" + tickets + "张票");
                tickets--;
            }

    }

2）同步静态方法：就是把synchronized关键字加到静态方法上

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

同步方法的锁对象：类名.class;

//重写run()方法中，
synchronized (SellTicket.class) {}//对应同步静态方法的锁对象 
//同步静态方法
    private static synchronized void sellTicket() {

        if (tickets > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":" + "正在出售第" + tickets + "张票");
            tickets--;
        }

    }

二、线程安全类

1）StringBuffer

2）Vector

3）Hashtable

三、Lock锁

public interface Lock // Lock是接口， 通过实现类ReentrantLock 来实例化 ，Reentrantlock的构造方法：Reentrantlock()：创建一个Reentrantlock的实例

Lock 实现提供比使用synchronized方法和语句可以获得的更广泛的锁定 *** 作。

Lock提供了获得锁和释放锁的方法：

1）void lock():：获得锁

2）void unlock()：释放锁

public class SellTicket implements Runnable{
    private int tickets=100;
    private Lock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {
                lock.lock();
                if(tickets>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+"正在出售第"+tickets+"张票");
                    tickets--;
                }
            }finally {
                lock.unlock();
            }

        }
    }
}