Yu's Github

Synchronized keyword bounds monitor to an object and has made concurrency programing simple. It can be added to method or object to achieve object level synchronization. It can also modify static method or class for class level synchronization.

// 修饰一个代码块
public void test1(int j) {
		synchronized (this) {
				for (int i = 0; i < 10; i++) {
						log.info("test1 {} - {}", j, i);
				}
		}
}

// 修饰一个方法
public synchronized void test2(int j) {
		for (int i = 0; i < 10; i++) {
				log.info("test2 {} - {}", j, i);
		}
}

public static void main(String[] args) {
		SynchronizedExample1 example1 = new SynchronizedExample1();
		SynchronizedExample1 example2 = new SynchronizedExample1();
		ExecutorService executorService = Executors.newCachedThreadPool();
		executorService.execute(() -> {
				example1.test2(1);
		});
		executorService.execute(() -> {
				example2.test2(2);
		});
}

// 修饰一个类
public static void test1(int j) {
		synchronized (SynchronizedExample2.class) {
				for (int i = 0; i < 10; i++) {
						log.info("test1 {} - {}", j, i);
				}
		}
}

// 修饰一个静态方法
public static synchronized void test2(int j) {
		for (int i = 0; i < 10; i++) {
				log.info("test2 {} - {}", j, i);
		}
}

public static void main(String[] args) {
		SynchronizedExample2 example1 = new SynchronizedExample2();
		SynchronizedExample2 example2 = new SynchronizedExample2();
		ExecutorService executorService = Executors.newCachedThreadPool();
		executorService.execute(() -> {
				example1.test1(1);
		});
		executorService.execute(() -> {
				example2.test1(2);
		});
}

Java provide several thread safe synchronized containers out of the box.

private static List<Integer> list = Collections.synchronizedList(Lists.newArrayList());
private static Set<Integer> set = Collections.synchronizedSet(Sets.newHashSet());
private static Map<Integer, Integer> map = Collections.synchronizedMap(new HashMap<>());
private static Map<Integer, Integer> map = new Hashtable<>();
private static List<Integer> list = new Vector<>();

Java and Guava also provide several immutable containers out of the box.

private static Map<Integer, Integer> map = Maps.newHashMap();
static {
		map.put(1, 2);
		map.put(3, 4);
		map.put(5, 6);
		map = Collections.unmodifiableMap(map);
}

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
private final static ImmutableList<Integer> list = ImmutableList.of(1, 2, 3);
private final static ImmutableSet set = ImmutableSet.copyOf(list);
private final static ImmutableMap<Integer, Integer> map = ImmutableMap.of(1, 2, 3, 4);
private final static ImmutableMap<Integer, Integer> map2 = ImmutableMap.<Integer, Integer>builder()
				.put(1, 2).put(3, 4).put(5, 6).build();