内置类与同步

一、内部类与静态内部类

PublicClass.java

/*
 * 内部类
 * 若Run.java和PublicClass.java不在同一个包中，则需要把PrivateClass类声明成public。
 * 在PrivateClass前面加上static即为静态内部类
 * 静态内部类不能访问外部类的非静态对象
 * 非静态内部类中不可以有静态成员。
 * 静态类和方法属于类本身。
 */
public class PublicClass {
static private String username;
static private String password;
static 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 void printInfo(){
		System.out.println(username+" "+password);
	}
}
public String getUsername(){
	return username;
}
public void setUsrname(String username){
	this.username=username;
}
public String getPassword(){
	return password;
}
public void setPassword(String password){
	this.password=password;
}
}

Run.java

public class Run {
public static void main(String[] args){
	PublicClass publicclass=new PublicClass();
	publicclass.setUsrname("ltt");
	publicclass.setPassword("lttPassword");
	System.out.println(publicclass.getUsername()+" "+publicclass.getPassword());
	/*
	 * 想要实例化内部类必须这样调用
	 * 	PrivateClass privateclass=publicclass.new PrivateClass();
	 */
	/*
	 * 静态内部类的调用可以不依赖于外部类而被实例化。
	 */
	PrivateClass privateclass=new PrivateClass();
	privateclass.setAge("18");
	privateclass.setAddress("beijing");
	System.out.println(privateclass.getAge()+" "+privateclass.getAddress());
}
}

二、内置类与同步

1.内置类中有两个同步的方法，使用的是不同的的锁，则结果是异步打印的。

outclass.java

public class OutClass {
		static class Inner{
			public void method1(){
				synchronized ("其他的锁") {
					for(int i=0;i<10;i++){
						System.out.println(Thread.currentThread().getName()+" i="+i);
						try {
							Thread.sleep(100);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
				}
			}
			public synchronized void method2(){
				for(int i=11;i<=20;i++){
					System.out.println(Thread.currentThread().getName()+" i="+i);
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}

Run.java

public class Run {
public static void main(String[] args){
	final Inner inner=new Inner();
	Thread t1=new Thread(new Runnable(){
		@Override
		public void run() {
			inner.method1();
		}	
	},"A");
	Thread t2=new Thread(new Runnable(){

		@Override
		public void run() {
			inner.method2();	
			}		
	},"B");
	t1.start();
	t2.start();
}
}

结果如下：

2.用同步代码块进行类锁，其他线程只能以同步的方式调用被锁类中的静态同步方法。

OutClass.java

public class OutClass {
static class InnerClass2{
	public synchronized void method1(){
		System.out.println(Thread.currentThread().getName()+"进入InnerClass2类里面的method1方法");
		for(int k=0;k<10;k++){
			System.out.println("k="+k);
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		}
		System.out.println(Thread.currentThread().getName()+"离开InnnerClass2类里面的method1方法");
	}
}
	static class InnerClass1{
		public void method1(InnerClass2 class2){
			synchronized (class2) {
				System.out.println(Thread.currentThread().getName()+"进入InnerClass1里面的method1方法");
				for(int i=0;i<10;i++){
					System.out.println("i="+i);
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
				System.out.println(Thread.currentThread().getName()+"离开InnerClass1里面的method1方法");
				}
		}
		public synchronized void method2(){
			System.out.println(Thread.currentThread().getName()+"进入InnerClass1里面的method2方法");
			for(int j=0;j<10;j++){
				System.out.println("j="+j);
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			System.out.println(Thread.currentThread().getName()+"离开InnerClass1里面的method2方法");
		}
	}
}

Run.java

public class Run {
public static void main(String[] args){
	final InnerClass1 in1=new InnerClass1();
	final InnerClass2 in2=new InnerClass2();
	Thread t1=new Thread(new Runnable(){
		@Override
		public void run() {
			in1.method1(in2);
		}	
	},"A");	
	Thread t2=new Thread(new Runnable(){
		@Override
		public void run() {
			in1.method2();
		}	
	},"B");
	Thread t3=new Thread(new Runnable(){
		@Override
		public void run() {
		  in2.method1();
		}	
	},"C");
	t1.start();
	t2.start();
	t3.start();
}
}

结果如下：

线程AB持有的是不同的锁，所以异步执行，而线程C要等待线程A 执行完后释放锁以后C才能执行。

三、只要对象不变，即使对象的属性变了，结果还是同步的。