初步使用synchronized及心得

假设需要实现以下功能: 设计一个并发程序,并发10个线程,每个线程累加sCount一百万次,将sCount加到一千万

public class SyncTest implements Runnable {
	
    public static int sCount = 0;
    
    private static String lock = new String();

    @Override
    public void run() {
        increaseCount();
    }

    private void increaseCount() {
    	/* 打印lock的内存地址 */
    	System.out.println(System.identityHashCode(lock));
    	synchronized (lock) {
            for (int i = 0; i < 1000000; i++) {
            	sCount++;
            }
		}
    }

    public static void main(String[] args) throws InterruptedException {
    	for (int i = 1; i <= 10; i++) {
            new Thread(new SyncTest(), "thread").start();;
		}
        
        Thread.sleep(1000);
    	System.out.println("\n"+sCount);
    }
}

我已线程需要使用到的Runnable是否唯一将实现方法分为两类

第一类:Runnable只有1个

1,用synchronized直接修饰increaseCount()方法(实例为锁);
2,用synchronized static修饰increaseCount()方法(类为锁);
3,用synchronized(this)将increaseCount的for循环包裹住(实例为锁);
4,用synchronized(SyncTest.class)将increaseCount的for循环包裹住(类为锁);
5,声明一个对象lock,确保其是唯一的,用synchronized(lock)将increaseCount的for循环包裹住(实例为锁);

第二类:Runnable有十个

1,用synchronized static修饰increaseCount()方法(类为锁);
2,用synchronized(SyncTest.class)将increaseCount的for循环包裹住(类为锁);
3,声明一个对象lock, 用static修饰lock, 用synchronized(lock)将increaseCount的for循环包裹住(实例为锁);

心得

通过以上解决之法可以看出,关键点就是不管锁住的是实例还是类,只要其是唯一的,就可以实现线程同步累加到目标值.
此外一定要注意锁的影响范围,比如类锁会影响到所有用此类为锁的实例对象,如无必要,应该缩小作用范围,比如使用静态实例作为锁.
还要注意在声明专用锁对象的时候,尽量不要使用String lock = ""这种常量申明方式,因为其在全局的常量池里都是唯一的,
锁的范围太大,可能会被使用同样方式的锁方法影响,最好使用String lock = new String();并确保在使用中锁住的对象实例是独有的即可.