2021-09-10

synchronized笔记

老韩零基础学Java，作业2

线程的同步
    线程同步机制
        1.在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，
        	保证数据在任何同一时刻， 最多有一个线程访问，以保证数据的完整性。
        2.也可以理解为：线程同步，即当有一个线程在对内存进行操作时，
        	其他线程都不可以对这个内存地址进行操作，
            直到该线程完成操作，其他线程才能对该内存地址进行操作

    同步具体方法-Synchronized
        1.同步代码块
            synchronized(对象){ //得到对象的锁，才能操作同步代码
                // 需要被同步代码;
            }

        2. synchronized 还可以放在方法声明中，表示整个方法-为同步方法
            public synchronized void m(String name){
                // 需要被同步的代码
            }
            
	互斥锁 ：synchronized
    基本介绍：
    1.在java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性
    2.每个对象都对应于一个可称为 "互斥锁" 的标记，这个标记用来保证在任意时刻，只能有一个线程访问对象
    3.关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized 修饰时，
    	表明该对象在任意时刻只能由一个线程访问
    4.同步的局限性：导致程序的执行效率要降低
    5.同步方法（非静态的）的锁可以是this,也可以是其他对象（要求是同一对象）
    6.同步方法（静态的）的锁为当前类本身


    注意事项
    1.同步方法如果没有使用static修饰：默认锁对象为this
    2.如果方法使用static修饰，默认锁对象：当前类.class

    3.实现的落地步骤
        需要先分析上锁的代码
        选择同步代码块或同步方法
        要求多个线程的锁对象为同一个即可
        
通过两种方式，锁同一个对象，避免超支取钱

package com.hspedu.homework_;

/**
 * @author rowling
 * @version 1.0
 */
 
public class HomeWork02 {


    public static void main(String[] args) {
        User user = new User();
        User2 user2 = new User2();
        user.start();
        user2.start();

//        User3 user3 = new User3();
//        Thread t1 = new Thread(user3);
//        t1.setName("t1");
//        t1.start();
//        Thread t2 = new Thread(user3);
//        t2.setName("t1");
//        t2.start();
    }
}

class User extends Thread{
    public static Integer money = 10000;
    private boolean loop = true;

    public void sell(){
        synchronized (money){
            if(money <= 0){
                System.out.println(Thread.currentThread().getName() + "没有余额...");
                loop = false;
                return ;
            }
            System.out.println(Thread.currentThread().getName() + "取钱后的金额还有："
            	+ (money-=1000));
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
    @Override
    public void run() {
        while (loop){
            sell();
        }
    }
}



class User2 extends Thread{
    private boolean loop = true;

    public void sell(){
        synchronized (User.money){
            if(User.money <= 0){
                System.out.println(Thread.currentThread().getName() + "没有余额...");
                loop = false;
                return ;
            }
            System.out.println(Thread.currentThread().getName() + "取钱后的金额还有：" 
            	+ (User.money-=1000));
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    @Override
    public void run() {
        while (loop){
            sell();
        }
    }
}


class User3 implements Runnable{
    public  int money = 10000;

    @Override
    public void run() {
        while (true){
            //解读：
            //1. 这里使用 synchronized 实现了线程同步
            //2. 当多个线程执行到这里时，就会去争夺 this 对象锁
            //3. 那个线程争夺（获取）this 对象锁，就执行 代码块，执行完后，会释放this对象锁
            //4. 争夺不到this 对象锁， 就 blocked, 准备继续争夺
            //5. this 对象锁非公平
            synchronized (this){
                if(money <= 0){
                    System.out.println(Thread.currentThread().getName() + "没有余额...");
                    break ;
                }
                System.out.println(Thread.currentThread().getName() + "取钱后的金额还有："
                	+ (money-=1000));
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}