内置类和对象锁改变 笔记记录

   当内置类是私有的，若实例化该类与内置类 在一个包下可以实例化。若不在一个包下要实例化，需要将内置类改为public

package com.inner;

public class PublicClass {
    private String username;
    private String password;
    
    
    public class PrivateClass{
    private String age;
    private String address;
    
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    
    
        
    }
    
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }

}

package com.test;

import com.inner.PublicClass;
import com.inner.PublicClass.PrivateClass;

public class Run {
    public static void main(String[] args) {
        PublicClass publicClass=new PublicClass();
        publicClass.setPassword("123456");
        publicClass.setUsername("a");
        
        PrivateClass privateClass=publicClass.new PrivateClass();
        privateClass.setAge("124");
        privateClass.setAddress("武汉");        
    }
}

当内置类为静态内置类时 不需要在使用publicClass.new PrivateClass() 实例化PrivateClass  因为静态变量 静态内置类都属于类所有，不属于对象所有。

对象锁改变：当开始执行时所有线程争夺同一个对象锁，线程同步，若两个线程由于所对象的改变，并不是争夺的同一个锁的时候线程异步。

package com.inner;

public class MyService {
    private String lock="123";
    public void testMethod(){
       synchronized(lock){
        try{
            System.out.println(Thread.currentThread().getName()+"   begin  "+System.currentTimeMillis());
            lock="456";
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName()+"   end    "+System.currentTimeMillis());
            
        }catch(InterruptedException e){
            
            e.printStackTrace();
        }
        
        
    }
    }

}

package com.inner;

public class ThreadA extends Thread{
  private MyService myService;
  public ThreadA(MyService myService){
      this.myService=myService;
      
  }
  public void run(){
      myService.testMethod();
      
      
  }
    
    
}
package com.inner;

public class ThreadB extends Thread{
  private MyService myService;
  public ThreadB(MyService myService){
      this.myService=myService;
      
  }
  public void run(){
      myService.testMethod();
      
      
  }
    
    
}


package com.inner;

public class Run {
    public static void main(String[] args) {
        MyService myService=new MyService();
        ThreadA  thread1=new ThreadA(myService);
        thread1.setName("a");
        ThreadB thread2=new ThreadB(myService);
        thread2.setName("b");
        thread1.start();
    /*    try{
            Thread.sleep(100);
            
        }catch(InterruptedException e){
            e.printStackTrace();
            
        }*/
        thread2.start();
        
        
    }

}

如果不加延时，两个线程几乎同时运行，争夺同一个对象，假若线程a拿到了该对象锁，即使在运行过程中lock="456" lock 改变了，但是线程2是等着线程a释放掉“123”的对象锁，如果加延时，线程a先运行,当执行到lock="456"时，线程b其实是得到对象“456”的锁。对象不一样因此异步。

该实例主要是用到了常量池缓存的特性。如果是对象，即使改变了对象的某个属性后，依然是同步的，因为对象没改变。