java synchronized java锁机制

java锁synchronized 解决的问题：
抢资源

关于锁方法    锁静态方法锁的锁 class，锁非静态方法锁的是类的实例  this  ，锁方法相当于锁代码块，不阻塞其他非锁部分代码块或者方法的执行

1.静态方法访问静态变量  

2.非静态方法访问静态变量

3.非静态方法访问非静态变量

关于锁代码块比较好理解，关键是理解锁的对象是什么 就可以了

以下是测试类

package com.sync;

/**
 * 同步锁
synchronized

锁方法
锁代码块
锁静态方法

测试1	(经过测试,锁方法相当于锁一个代码块,锁的对象是this)
锁普通方法,并且调用锁方法的同时调用该对象的其他方法,测试 锁定该方法是否影响该对象的其他方法

测试2	
锁静态代码块


抢资源
关于锁方法  锁方法相当于锁代码块，不影响当前对象的其他方法执行，不阻塞
静态方法访问静态变量
非静态方法访问静态变量
非静态方法访问非静态变量

关于锁代码块很好理解

 * @author hyz79
 */
public class SyncTest {
	
	private static class SyncTest1{
		public synchronized void sync(){
			System.out.println("我上锁了");
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("我在执行");
			System.out.println("我执行完成");
		}
		
		public void other(){
			System.out.println("悠悠达达执行其他方法..");
		}
		/***
		 * 测试锁方法,在执行该方法的时候 是否影响其它方法的执行
		 * 
		 * 结果1.如果  悠悠达达执行其他方法..行的输出 不在
		 * 我上锁了
		 * 我在执行
		 * 我执行完成
		 * 这个 中间  ,说明锁当前这个对象的 所有方法
		 * 结果2.如果在其中输出 说明,锁的仅仅是这个方法,相当于锁代码块
		 * 
		 * 执行结果  结论:锁非静态方法相当于锁一个代码块 ,这个方法做为一个代码块,锁当前对象
我上锁了
我在执行
我执行完成
我上锁了
悠悠达达执行其他方法..
我在执行
我执行完成
悠悠达达执行其他方法..
我上锁了
我在执行
我执行完成
悠悠达达执行其他方法..
我上锁了
我在执行
我执行完成
我上锁了
悠悠达达执行其他方法..
我在执行
我执行完成
悠悠达达执行其他方法..
我上锁了
我在执行
我执行完成
悠悠达达执行其他方法..
我上锁了
我在执行
我执行完成
悠悠达达执行其他方法..
我上锁了
我在执行
我执行完成
我上锁了
悠悠达达执行其他方法..
我在执行
我执行完成
我上锁了
悠悠达达执行其他方法..
我在执行
我执行完成
悠悠达达执行其他方法..
		 */
		public static void test(){
			final SyncTest1 t1 = new SyncTest1();
			
			for(int i=0;i<10;i++){
				new Thread(new Runnable() {
					@Override
					public void run() {
						t1.sync();
						t1.other();
					}
				}).start();;
			}
		}
	}
	
	private static class SyncTest2{
		public static int C = 0;
		
		public synchronized static void sync(){
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			C++;
			System.out.println(C);
		}
		
		public static void test1(){
			for(int i=0;i<10;i++){
				new Thread(new Runnable() {
					@Override
					public void run() {
						SyncTest2.sync();
					}
				}).start();
			}
		}
	}
	
	private static class SyncTest3{
		public static int C = 0;
		
		public synchronized void sync(){
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			C++;
			System.out.println(C);
		}
		
		public static void test(){
			for(int i=0;i<1000;i++){
				new Thread(new Runnable() {
					@Override
					public void run() {
						new SyncTest3().sync();
					}
				}).start();
			}
		}
	}
	private static class Obj{
		public int i;
		public void add(){
			System.out.println(i++);
		}
	}
	private static class SyncTest4{
		public static synchronized void test(Obj obj){
			obj.add();
		}
		
		public static void test(){
			final Obj obj = new Obj();
			for(int i=0;i<100;i++){
				new Thread(new Runnable() {
					@Override
					public void run() {
						test(obj);
					}
				}).start();
			}
		}
	}
	
	public static void main(String[] args) {
		//SyncTest1.test();
		//SyncTest2.test1();
		SyncTest3.test();
//		SyncTest4.test();
	}
	
	
}