synchronized关键字(笔记)

最新推荐文章于 2024-10-01 09:29:45 发布

旭子在努力

最新推荐文章于 2024-10-01 09:29:45 发布

阅读量711

点赞数

分类专栏：笔记文章标签： java 学习

本文链接：https://blog.csdn.net/weixin_44784393/article/details/123764179

版权

笔记专栏收录该内容

30 篇文章 0 订阅

订阅专栏

之前我们讲过的AtomicInteger可以对“int类型的变量”做原子操作。但如果需要将“很多行代码”一起作为“原子性”执行——一个线程进入后，必须将所有代码行执行完毕，其它线程才能进入，可以使用synchronized关键字——重量级的同步关键字。

AtomicInteger:只能解决一个变量的原子性
synchronized:可以解决一段代码的原子性

1.售票案例引发的安全性问题(了解)
在这里插入图片描述
2.售票案例的代码实现(重点)

package com.itheima.demo07payTicket;

/*
    卖票案例:创建3个线程,卖同100张票
 */
public class RunnableImpl implements Runnable {
    //定义一个供3个线程共享的票源
    private int ticket = 100;
    //线程任务:卖票==>票依次减少
    @Override
    public void run() {
        //增加一个死循环:让线程重复卖票
        while (true){
            //对票进行判断大于0在卖票
            if(ticket>0){
                //卖出每张票需要10毫秒
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"现在正在卖第"+ticket+"张票!");
                ticket--;
            }else{
                break;
            }
        }
    }
}

package com.itheima.demo07payTicket;

public class Demo01PayTicket {
    public static void main(String[] args) {
        Runnable run = new RunnableImpl();
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        t0.start();
        t1.start();
        t2.start();
    }
}

程序执行的结果:

...
Thread-2现在正在卖第16张票!
Thread-1现在正在卖第16张票!
Thread-0现在正在卖第16张票!
Thread-0现在正在卖第13张票!
Thread-1现在正在卖第12张票!
Thread-2现在正在卖第11张票!
Thread-0现在正在卖第10张票!
Thread-1现在正在卖第9张票!
Thread-2现在正在卖第9张票!
Thread-0现在正在卖第7张票!
Thread-1现在正在卖第6张票!
Thread-2现在正在卖第5张票!
Thread-0现在正在卖第4张票!
Thread-1现在正在卖第3张票!
Thread-2现在正在卖第3张票!
Thread-0现在正在卖第1张票!
Thread-2现在正在卖第0张票!
Thread-1现在正在卖第-1张票!

在这里插入图片描述
继承方式实现卖票案例

package com.itheima.demo07payTicket;

public class MyThread extends Thread {
    //定义一个供3个线程共享的票源
    private static int ticket = 100;
    //线程任务:卖票==>票依次减少
    @Override
    public void run() {
        //增加一个死循环:让线程重复卖票
        while (true){
            //对票进行判断大于0在卖票
            if(ticket>0){
                //卖出每张票需要10毫秒
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"现在正在卖第"+ticket+"张票!");
                ticket--;
            }else{
                break;
            }
        }
    }
}

package com.itheima.demo07payTicket;

public class Demo02PayTicket {
    public static void main(String[] args) {
        //创建Thread类的子类对象
        MyThread t0 = new MyThread();
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        t0.start();
        t1.start();
        t2.start();
    }
}

3.线程安全问题的产生原理(了解-扩展知识点)
在这里插入图片描述
4.解决线程安全问题的第一种方式使用同步代码块(重点)

package com.itheima.demo08synchronized;

/*
    卖票案例:创建3个线程,卖同100张票
    出现了线程安全问题:卖出了重复的票和不存在的票
    解决线程安全问题的第一种方式:使用同步代码块
    格式:
        synchronized(锁对象){
            可能产生线程安全问题的代码(访问了共享数据的代码)
        }
    原理:
        使用同步代码块把一段代码锁住,只让一个线程进入到代码块中执行卖票的代码
    注意:
        1.同步代码块使用的锁对象可以是任意的对象
               Student s = new Student();Object obj = new Object();String s = "abc"; //底层是一个字符数组
        2.必须保证所有的线程使用的是同一个锁对象
 */
public class RunnableImpl implements Runnable {
    //定义一个供3个线程共享的票源
    private int ticket = 100;
    //定义一个锁对象:供所有的线程使用
    //private Student stu = new Student();
    //private Object obj = new Object();
    private String str = "abc";

    //线程任务:卖票==>票依次减少
    @Override
    public void run() {
        //增加一个死循环:让线程重复卖票
        while (true){
            //同步代码块
            synchronized (str){
                //对票进行判断大于0在卖票
                if(ticket>0){
                    //卖出每张票需要10毫秒
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"现在正在卖第"+ticket+"张票!");
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}

package com.itheima.demo08synchronized;

public class Demo01PayTicket {
    public static void main(String[] args) {
        Runnable run = new RunnableImpl();
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        t0.start();
        t1.start();
        t2.start();
    }
}

5.同步的原理(了解-扩展知识点)
在这里插入图片描述
6.解决线程安全问题的第二种方式:使用同步方法(重点)

package com.itheima.demo09synchronized;

/*
    卖票案例:创建3个线程,卖同100张票
    出现了线程安全问题:卖出了重复的票和不存在的票
    解决线程安全问题的第二种方式:使用同步方法
    步骤:
        1.把访问了共享数据的代码,抽取出来,放到一个方法中
        2.给方法添加一个synchronized关键字,这个方法就是一个同步方法
    格式:
        修饰符 synchronized 返回值类型 方法名(参数列表){
            可能产生线程安全问题的代码(访问了共享数据的代码)
        }
    原理:
        使用一个同步方法把代码锁住,只让一个线程进入到方法执行卖票的代码

 */
public class RunnableImpl implements Runnable {
    //定义一个供3个线程共享的票源
    private static int ticket = 100;
    //线程任务:卖票==>票依次减少
    @Override
    public void run() {
        //System.out.println("this:"+this);
        //增加一个死循环:让线程重复卖票
        while (true){
            //调用同步方法
            //payTicket();
            //调用静态的同步方法
            payTicketStatic();
            if(ticket<=0){
                break;
            }
        }
    }

    /*
        了解
        定义一个静态同步方法,把访问了共享数据的代码,抽取到方法中
        问题:静态的同步方法的锁对象是谁? 是this吗? 不this:this是创建对象才有的
        静态方法优先于对象进入到内存中
        静态方法的锁对象是:本类的class文件对象 RunnableImpl.class==>唯一(反射)
     */
    public static /*synchronized*/ void payTicketStatic(){
        synchronized (RunnableImpl.class){
            //对票进行判断大于0在卖票
            if(ticket>0){
                //卖出每张票需要10毫秒
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"现在正在卖第"+ticket+"张票!");
                ticket--;
            }
        }
    }

    /*
        定义一个同步方法,把访问了共享数据的代码,抽取到方法中
        原理:也是使用一个锁对象,把代码锁住,只让一个线程进入到方法中执行
        同步方法使用的锁对象是谁? this==>创建的本类对象==>new RunnableImpl()
     */
    public synchronized void payTicket(){
        //对票进行判断大于0在卖票
        if(ticket>0){
            //卖出每张票需要10毫秒
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"现在正在卖第"+ticket+"张票!");
            ticket--;
        }
    }

    /*public  void payTicket(){
        synchronized (this){
            //对票进行判断大于0在卖票
            if(ticket>0){
                //卖出每张票需要10毫秒
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"现在正在卖第"+ticket+"张票!");
                ticket--;
            }
        }
    }*/
}

package com.itheima.demo09synchronized;

public class Demo01PayTicket {
    public static void main(String[] args) {
        Runnable run = new RunnableImpl();
        System.out.println("run:"+run);
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        t0.start();
        t1.start();
        t2.start();
    }
}

7.解决线程安全问题的第三方式:使用Lock锁(重点)
在这里插入图片描述

在这里插入图片描述

package com.itheima.demo10Lock;

import java.util.concurrent.locks.ReentrantLock;

/*
    卖票案例:创建3个线程,卖同100张票
    出现了线程安全问题:卖出了重复的票和不存在的票
    解决线程安全问题的第三种方式:使用Lock锁
    java.util.concurrent.locks.Lock接口,是JDK1.5之后出现的
        Lock锁比同步代码块和同步方法使用起来更广泛。
    Lock接口中的成员方法:
        void lock()获取锁。
        void unlock() 释放锁。
    java.util.concurrent.locks.ReentrantLock类 implements Lock接口
    Lock锁的使用步骤:
        1.在成员位置创建ReentrantLock对象
        2.在访问共享数据的代码前调用lock方法,获取锁对象
        3.在访问共享数据的代码后调用unlock方法,释放锁对象
    原理:
        使用lock方法和unlock方法把一段代码锁住,只让一个线程进入执行
 */
public class RunnableImpl implements Runnable {
    //定义一个供3个线程共享的票源
    private int ticket = 100;
    //1.在成员位置创建ReentrantLock对象
    private ReentrantLock l = new ReentrantLock();

    //线程任务:卖票==>票依次减少
    @Override
    public void run() {
        //增加一个死循环:让线程重复卖票
        while (true){
            //2.在访问共享数据的代码前调用lock方法,获取锁对象
            l.lock();
                //对票进行判断大于0在卖票
                if(ticket>0){
                    //卖出每张票需要10毫秒
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"现在正在卖第"+ticket+"张票!");
                    ticket--;
                }
            //3.在访问共享数据的代码后调用unlock方法,释放锁对象
            l.unlock();
            if(ticket<=0){
                break;
            }
        }
    }
}

package com.itheima.demo10Lock;

public class Demo01PayTicket {
    public static void main(String[] args) {
        Runnable run = new RunnableImpl();
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        t0.start();
        t1.start();
        t2.start();
    }
}

8.CAS与synchronized

AtomicInteger:只能解决一个变量的原子性
synchronized:可以解决一段代码的原子性
CAS和Synchronized都可以保证多线程环境下共享数据的安全性。那么他们两者有什么区别？
Synchronized是从悲观的角度出发：
总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁
（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。因此Synchronized我们也将其称之为悲观锁。jdk中的ReentrantLock也是一种悲观锁。
CAS是从乐观的角度出发:
总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据。
CAS这种机制我们也可以将其称之为乐观锁。

🎗经验分享

1. 代码

Runnable实现类

public class Ticket implements Runnable{
    int count = 100;
    @Override
    public void run() {
        while (true) {
            synchronized (new Object()) {
                try {
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (count > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在卖票：" + count--);
                }
            }
        }
    }
}

测试类

public class Demo01Test {
    public static void main(String[] args) {
        Ticket t = new Ticket();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
    }
}

2.出现的问题
使用了同步代码块，但是运行之后依旧发生了线程安全问题
在这里插入图片描述
3.问题的分析

如果使用同步代码块，并且要保证线程安全，那么需要使用同一个锁对象，而在现在的程序中，多个线程使用的并不是同一个锁，所以产生了线程安全问题。

4.问题解决办法

让多个线程使用同一个锁对象，比如锁对象使用this

public class Ticket implements Runnable{
    int count = 100;
    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                try {
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (count > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在卖票：" + count--);
                }
            }
        }
    }
}