java 线程同步锁

淡淡的烟草味﹌ 2024-04-18 11:09 113阅读 0赞

package com;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class Damo7 {
    	public static void main(String[] args) {
    		method2_2();
    	}
    	/*
    	 * 同步问题原因分析 
    	 * 1. 假设增加线程先进入，得到的hp是10000 
    	 * 2. 进行增加运算 
    	 * 3. 正在做增加运算的时候，还没有来得及修改hp的值，减少线程来了
    	 * 4. 减少线程得到的hp的值也是10000 
    	 * 5. 减少线程进行减少运算 
    	 * 6. 增加线程运算结束，得到值10001，并把这个值赋予hp 
    	 * 7.减少线程也运算结束，得到值9999，并把这个值赋予hp hp，最后的值就是9999
    	 * 虽然经历了两个线程各自增减了一次，本来期望还是原值10000，但是却得到了一个9999 这个时候的值9999是一个错误的值，
    	 * 在业务上又叫做脏数据
    	 */
    	/*
    	 * 总体解决思路是： 在增加线程访问hp期间，其他线程不可以访问hp 
    	 * 1. 增加线程获取到hp的值，并进行运算
    	 * 2.在运算期间，减少线程试图来获取hp的值，但是不被允许 
    	 * 3. 增加线程运算结束，并成功修改hp的值为10001 
    	 * 4.减少线程，在增加线程做完后，才能访问hp的值，即10001 
    	 * 5. 减少线程运算，并得到新的值10000
    	 */
    	/*
    	 * 解决上述问题之前，先理解synchronized关键字的意义 如下： Object lock =new Object();,以及超类的子类
    	 * synchronized (lock){ //此处的代码只有占有了someObject后才可以执行 }
    	 * 
    	 * synchronized表示当前线程，
    	 *  独占对象 lock 当前线程独占了对象lock，如果有其他线程试图占有对象lock，就会等待， 直到当前线程释放对lock的占用 
    	 * lock又叫同步对象，所有的对象，都可以作为同步对象 为了达到同步的效果，必须使用同一个同步对象
    	 * 
    	 * 释放同步对象的方式： synchronized 块自然结束，或者有异常抛出
    	 */
    
    	public static void method2_1() {
    		final Object someObject = new Object();
    
    		Thread t1 = new Thread() {
    			public void run() {
    				try {
    					System.out.println(now() + " t1 线程已经运行");
    					System.out.println(now() + this.getName() + " 试图占有对象：someObject");
    					synchronized (someObject) {
    						System.out.println(now() + this.getName() + " 占有对象：someObject");
    						Thread.sleep(3000);
    						System.out.println(now() + this.getName() + " 释放对象：someObject");
    					}
    					System.out.println(now() + " t1 线程结束");
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			}
    		};
    		t1.setName(" t1");
    		t1.start();
    		Thread t2 = new Thread() {
    			public void run() {
    				try {
    					System.out.println(now() + " t2 线程已经运行");
    					System.out.println(now() + this.getName() + " 试图占有对象：someObject");
    					synchronized (someObject) {
    						System.out.println(now() + this.getName() + " 占有对象：someObject");
    						Thread.sleep(30);
    						System.out.println(now() + this.getName() + " 释放对象：someObject");
    					}
    					System.out.println(now() + " t2 线程结束");
    				} catch (InterruptedException e) {
    					
    					e.printStackTrace();
    				}
    			}
    		};
    		t2.setName(" t2");
    		t2.start();
    	}
    	// 格式化时间输出
    		public static String now() {
    			return new SimpleDateFormat("HH:mm:ss").format(new Date());
    		}
    	
    
    		/*
    		 * 所有需要修改hp的地方，有要建立在占有someObject的基础上。 而对象 someObject在同一时间，只能被一个线程占有。
    		 * 间接地，导致同一时间，hp只能被一个线程修改。
    		 */
    		public static void method2_2() {
    			final Object lock = new Object();
    			// jdk1.7后不加final
    			Hero3 xiangyu = new Hero3();
    			xiangyu.name = "项羽";
    			xiangyu.hp = 10000;
    			// 定义五个加血线程
    			Thread[] recoverT = new Thread[5];
    			// 定义五个掉血线程
    			Thread[] hurtT = new Thread[5];
    			// 对10个线程进行初始化
    			for (int i = 0; i < 5; i++) {
    				recoverT[i] = new Thread(new Runnable() {
    					public void run() {
    						try {
    							Thread.sleep(50);
    						} catch (InterruptedException e) {
    							e.printStackTrace();
    						}
    						//synchronized (lock) {
    						//这个地方可以有两种方式去写，这是在类方法中去写lock
    						//下面那个线程是直接在线程中去写lock
    							xiangyu.recover();
    						//}
    						System.out.println("recover-->" + xiangyu.hp);
    					}
    				});
    				hurtT[i] = new Thread(new Runnable() {
    					public void run() {
    						synchronized (lock) {
    							xiangyu.hurt();
    						}
    						System.out.println("hurt-->" + xiangyu.hp);
    					}
    				});
    			}
    			// 开启10个线程
    			for (Thread t : recoverT) {
    				t.start();
    			}
    			for (Thread t : hurtT) {
    				t.start();
    			}
    			new Thread(new Runnable() {
    				public void run() {
    					try {
    						Thread.sleep(1000);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					System.out.println("--->" + xiangyu);
    				}
    			}).start();
    		}
    }
    
    
    class Hero3 {
    	public String name;
    	public float hp;
    	public int damage;
    	// 回血
    	public synchronized void recover() {
    		hp = hp + 1;
    	}
    	// 掉血
    	public void hurt() {
    		hp = hp - 1;
    	}
    	public void attackHero(Hero3 h) {
    		h.hp -= damage;
    		System.out.format("%s 正在攻击 %s, %s的血变成了 %.0f%n", name, h.name, h.name, h.hp);
    		if (h.isDead())
    			System.out.println(h.name + "死了！");
    	}
    	public boolean isDead() {
    		return 0 >= hp ? true : false;
    	}
    	public String toString() {
    		return "Hero [name=" + name + ", hp=" + hp + ", damage=" + damage + "]";
    	}
    }