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

最新推荐文章于 2024-11-05 19:12:16 发布

原创最新推荐文章于 2024-11-05 19:12:16 发布 · 279 阅读

0 ·

CC 4.0 BY-SA版权

java多线程专栏收录该内容

3 篇文章

订阅专栏

本文探讨了Java中内置类的访问权限及其实例化条件，并通过实例演示了线程同步中对象锁的变化如何影响线程的行为。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

当内置类是私有的，若实例化该类与内置类在一个包下可以实例化。若不在一个包下要实例化，需要将内置类改为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”的锁。对象不一样因此异步。