synchronized学习总结

最新推荐文章于 2024-10-17 23:02:04 发布

Lqw7

最新推荐文章于 2024-10-17 23:02:04 发布

阅读量108

点赞数

文章标签： java 多线程

本文链接：https://blog.csdn.net/weixin_43759462/article/details/113362754

版权

本文通过一个售票案例探讨了Java多线程中可能出现的同步问题，展示了如何使用`synchronized`关键字解决并发安全问题，以及`synchronized`的优缺点。进一步介绍了Lock接口的使用，特别是`ReentrantLock`类，强调了手动释放锁的重要性，以及Lock相对于`synchronized`的灵活性和控制粒度。

摘要由CSDN通过智能技术生成

Java多线程案例

100张电影票分别由三个窗口销售

public class SellTicket implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                //模拟出票
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在出售第" + ticket + "张票");
                ticket--;
            }
        }
    }
}

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();
    }
}

运行结果：
在这里插入图片描述
该程序会出现同一张票被卖了多次的问题。
t1线程抢到CPU执行权，t1线程开始执行，先休息1000毫秒；
t2线程抢到CPU执行权，t2线程开始执行，先休息1000毫秒；
t3线程抢到CPU执行权，t3线程开始执行，先休息1000毫秒；
假设线程按顺序醒过来；
t1在控制台输出：窗口一正在售出第100张票；
t2在控制台输出：窗口二正在售出第100张票；
t3在控制台输出：窗口三正在售出第100张票；
之后三个线程分别执行三次ticket–；
ticket = 97；

使用同步代码块解决问题

使用synchronized把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
synchronized是Java中的关键字，是一种同步锁。
synchronized(任意对象)：相当于给代码加锁了，任意对象就可以看成是一把锁

好处：解决了多线程的数据安全问题
弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的

运行效率

public class SellTicket implements Runnable {
    private int ticket = 100;
    Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            //ticket = 100;
            //假设t1抢到cpu执行权
            //假设t2抢到cpu执行权
            synchronized (obj){
                //t1进来后就会把这段代码锁起来
                if (ticket > 0) {
                    //模拟出票
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + ticket + "张票");
                    ticket--; //ticket = 99
                }
                //t1出来后这段代码解锁
            }

        }
    }
}

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();
    }
}

运行结果：
在这里插入图片描述
synchronized的应用
synchronized修饰方法

public synchronized void method()
{
  
}

或

public void method()
{
   synchronized(this) {
    
   }
}

Synchronized也可修饰一个静态方法

public synchronized static void method() {
//
}

代码修改：

public class SellTicket implements Runnable {
    private int ticket = 100;
    Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            sellTicket();
        }
    }


    private synchronized void sellTicket() {
        if (ticket > 0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在出售第" + ticket + "张票");
            ticket--;
        }
    }
}

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();
    }
}

Lock锁

Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；
Lock是接口不能直接实例化，而是采用它的实现类ReentrantLock来实例化
Lock和synchronized不同的是，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SellTicket implements Runnable {
    private int ticket = 100;
    Object obj = new Object();
    private Lock lock = new ReentrantLock();


    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + ticket + "张票");
                    ticket--;
                }
            } finally {
                lock.unlock();
            }
        }
        
    }


    private synchronized void sellTicket() {
        if (ticket > 0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在出售第" + ticket + "张票");
            ticket--;
        }
    }
}

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();
    }
}