Java线程同步

赵广陆

已于 2022-04-11 14:32:32 修改

阅读量1.1k

点赞数 1

分类专栏： java 文章标签： java 锁

于 2020-08-03 10:15:55 首次发布

本文链接：https://blog.csdn.net/ZGL_cyy/article/details/107756643

版权

java 专栏收录该内容

196 篇文章 19 订阅

订阅专栏

1 卖票【应用】

案例需求

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

实现步骤

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

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

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

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

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

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

创建 SellTicket 类的对象

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

启动线程

代码实现

public class SellTicket implements Runnable {
    private int tickets = 100;
    //在SellTicket类中重写run()方法实现卖票，代码步骤如下
    @Override
    public void run() {
        while (true) {
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + "正在出售第" +
                        tickets + "张票");
                tickets--;
            }
        }
    }
}
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();
    }
}

执行结果

2 卖票案例的问题【理解】

卖票出现了问题

相同的票出现了多次

出现了负数的票

问题产生原因

线程执行的随机性导致的

public class SellTicket implements Runnable {
    private int tickets = 100;
    @Override
    public void run() {
//相同的票出现了多次
// while (true) {
// //tickets = 100;
// //t1,t2,t3
// //假设t1线程抢到CPU的执行权
// if (tickets > 0) {
// //通过sleep()方法来模拟出票时间
// try {
// Thread.sleep(100);
// //t1线程休息100毫秒
// //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休
        息100毫秒
// //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休
                息100毫秒
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// //假设线程按照顺序醒过来
// //t1抢到CPU的执行权，在控制台输出：窗口1正在出售第100张票
// System.out.println(Thread.currentThread().getName() + "正在出售第"
        + tickets + "张票");
// //t2抢到CPU的执行权，在控制台输出：窗口2正在出售第100张票
// //t3抢到CPU的执行权，在控制台输出：窗口3正在出售第100张票
// tickets--;
// //如果这三个线程还是按照顺序来，这里就执行了3次--的操作，最终票就变成了97
// }
// }
//出现了负数的票
        while (true) {
//tickets = 1;
//t1,t2,t3
//假设t1线程抢到CPU的执行权
            if (tickets > 0) {
//通过sleep()方法来模拟出票时间
                try {
                    Thread.sleep(100);
//t1线程休息100毫秒
//t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息
                    100毫秒
//t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息
                    100毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
//假设线程按照顺序醒过来
//t1抢到了CPU的执行权，在控制台输出：窗口1正在出售第1张票
//假设t1继续拥有CPU的执行权，就会执行tickets--;操作，tickets = 0;
//t2抢到了CPU的执行权，在控制台输出：窗口1正在出售第0张票
//假设t2继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -1;
//t3抢到了CPU的执行权，在控制台输出：窗口3正在出售第-1张票
//假设t2继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -2;
                System.out.println(Thread.currentThread().getName() + "正在出售第" +
                        tickets + "张票");
                tickets--;
            }
        }
    }
}

3 同步代码块解决数据安全问题【应用】

安全问题出现的条件

是多线程环境

有共享数据

有多条语句操作共享数据

如何解决多线程安全问题呢 ?

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

怎么实现呢 ?

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

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

同步代码块格式：

synchronized ( 任意对象 ) {

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

}

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

同步的好处和弊端

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

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

代码演示

public class SellTicket implements Runnable {
    private int tickets = 100;
    private Object obj = new Object();
    @Override
    public void run() {
        while (true) {
//tickets = 100;
//t1,t2,t3
//假设t1抢到了CPU的执行权
//假设t2抢到了CPU的执行权
            synchronized (obj) {
//t1进来后，就会把这段代码给锁起来
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
//t1休息100毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
//窗口1正在出售第100张票
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                            tickets--; //tickets = 99;
                }
            }
//t1出来了，这段代码的锁就被释放了
        }
    }
}
public class SellTicketDemo {
    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();
    }
}

4 同步方法解决数据安全问题【应用】

同步方法的格式同步方法：就是把synchronized 关键字加到方法上

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

方法体；

}

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

this

静态同步方法

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

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

方法体；

}

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

类名 .class

代码演示

public class SellTicket implements Runnable {
    private static int tickets = 100;
    private int x = 0;
    @Override
    public void run() {
        while (true) {
            sellTicket()；
        }
    }
// 同步方法
// private synchronized void sellTicket() {
// if (tickets > 0) {
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println(Thread.currentThread().getName() + "正在出售第" +
    tickets + "张票");
    // tickets--;
// }
// }
// 静态同步方法
    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--;
        }
    }
}
public class SellTicketDemo {
    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();
    }
}

5 线程安全的类【理解】

StringBuffffer

线程安全，可变的字符序列

从版本 JDK 5 开始，被 StringBuilder 替代。通常应该使用 StringBuilder 类，因为它支持所有相同的操

作，但它更快，因为它不执行同步

Vector

从 Java 2 平台 v1.2 开始，该类改进了 List 接口，使其成为 Java Collections Framework 的成员。与新的集

合实现不同， Vector 被同步。如果不需要线程安全的实现，建议使用 ArrayList 代替 Vector

Hashtable

该类实现了一个哈希表，它将键映射到值。任何非 null 对象都可以用作键或者值

从 Java 2 平台 v1.2 开始，该类进行了改进，实现了 Map 接口，使其成为 Java Collections Framework 的成

员。与新的集合实现不同， Hashtable 被同步。如果不需要线程安全的实现，建议使用 HashMap 代替

Hashtable

6 Lock锁【应用】

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了

锁，为了更清晰的表达如何加锁和释放锁， JDK5 以后提供了一个新的锁对象 Lock

Lock 是接口不能直接实例化，这里采用它的实现类 ReentrantLock 来实例化:

private ReentrantLock lock = new ReentrantLock();

ReentrantLock类中有很多的方法：

/**
     * 阻塞等待获取锁;不允许Thread.interrupt中断,即使检测到Thread.isInterrupted,一样会继续尝试      * 获取锁，失败则继续休眠。只是在最后获取锁成功后再把当前线程置为interrupted状态,然后再中断线程。
     */
    public void lock() {
        sync.lock();
    }

    /**
     * 当前线程未被中断，则获取锁
     * 允许在等待时由其它线程调用等待线程的Thread.interrupt方法来中断等待线程的等待而直接返回，这时      * 不用获取锁，而会抛出一个InterruptedException
     */
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    /**
     *尝试申请一个锁，在成功获得锁后返回true，否则，立即返回false
     */
    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

    /**
     * 在一段时间内尝试申请一个锁，在成功获得锁后返回true，否则，立即返回false
     */
    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

    /**
     * 释放锁
     */
    public void unlock() {
        sync.release(1);
    }

    /**
     * 条件实例
     */
    public Condition newCondition() {
        return sync.newCondition();
    }

    /**
     * 获取当前线程持有此锁的次数
     */
    public int getHoldCount() {
        return sync.getHoldCount();
    }

    /**
     * 是否被当前线程持有
     */
    public boolean isHeldByCurrentThread() {
        return sync.isHeldExclusively();
    }

    /**
     * 查询此锁是否由任意线程持有
     */
    public boolean isLocked() {
        return sync.isLocked();
    }

    /**
     *如果是“公平锁”返回true，否则返回false
     */
    public final boolean isFair() {
        return sync instanceof FairSync;
    }

    /**
     * 获取目前拥有此锁的线程，如果此锁不被任何线程拥有，则返回 null
     */
    protected Thread getOwner() {
        return sync.getOwner();
    }

    /**
     * 查询是否有线程正在等待
     */
    public final boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }

    /**
     *查询给定线程是否正在等待获取此锁。
     */
    public final boolean hasQueuedThread(Thread thread) {
        return sync.isQueued(thread);
    }

    /**
     * 获取正等待获取此锁的线程数
     */
    public final int getQueueLength() {
        return sync.getQueueLength();
    }
   /**
     * 正等待获取此锁的线程集合
     */
    protected Collection<Thread> getQueuedThreads() {
        return sync.getQueuedThreads();
    }
 /**
     *是否存在正在等待并符合相关给定条件的线程
     */
    public boolean hasWaiters(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

    /**
     * 正在等待并符合相关给定条件的线程数量
     */
    public int getWaitQueueLength(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

    /**
     * 正在等待并符合相关给定条件的线程集合
     */
    protected Collection<Thread> getWaitingThreads(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

代码演示

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();
            }
        }
    }
}
public class SellTicketDemo {
    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();
    }
}