Java高并发程序-Chapter4 并行模式与算法（第二十三讲）单利模式

最新推荐文章于 2024-08-10 06:00:00 发布

原创最新推荐文章于 2024-08-10 06:00:00 发布 · 221 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#并发编程

并发编程同时被 2 个专栏收录

34 篇文章

订阅专栏

Java高并发程序

34 篇文章

订阅专栏

本文深入探讨了单例模式的不同实现方式，包括饿汉模式、懒汉模式及其优化版本。通过对比不同模式的特点，帮助读者理解如何选择合适的单例模式来提高程序的性能和安全性。

1.饿汉模式

package com.john.learn.high.concurent.ch04.singleton;

public class StarvationSingleton {

	public StarvationSingleton() {

		System.out.println("Starvation Singleton is created...");
	}

	public static StarvationSingleton getInstance() {
		return instance;
	}

	private static StarvationSingleton instance = new StarvationSingleton();

}

2. 懒汉模式

package com.john.learn.high.concurent.ch04.singleton;

public class LazySingleton {

  public LazySingleton() {

    System.out.println("LazySingleton Singleton is created...");
  }


  public static LazySingleton getInstance() {


    if (instance != null) {

     return instance;
    }


    synchronized (LazySingleton.class) {

     if (instance == null) {


       instance = new LazySingleton();
     }

    }

    return instance;

  }


  private static LazySingleton instance;


}

3. 优化单利模式1

package com.john.learn.high.concurent.ch04.singleton;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FreeLazySingleton {

	public FreeLazySingleton() {

		System.out.println("FreeLazySingleton is created...");
	}

	public static synchronized FreeLazySingleton getInstance() {

		return FreeLazySingletonHolder.getInstance();
	}

	private static class FreeLazySingletonHolder {

		private static FreeLazySingleton instance = new FreeLazySingleton();

		public static FreeLazySingleton getInstance() {
			return instance;
		}
	}

	private static FreeLazySingleton instance;

	public static void main(String[] args) {

		ExecutorService executorService = Executors.newCachedThreadPool();

		for (int i = 0; i < 10; i++) {

			executorService.submit(new Runnable() {

				@Override
				public void run() {

					FreeLazySingleton.getInstance();

				}
			});
		}

		executorService.shutdown();
	}

}

4. 优化单利模式2 （CAS）

package com.john.learn.high.concurent.ch04.singleton;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;


public class FreeLockSingleton {


	public FreeLockSingleton() {


		System.out.println("FreeLockSingleton is created...");
	}


	public static FreeLockSingleton getInstance() {


		if (instance != null) {


			return instance;
		}


		for (;;) {


			if (createInstanceCertificate.compareAndSet(false, true)) {


				instance = new FreeLockSingleton();


			}


			if (instance != null) {


				return instance;
			}


		}
	}
	
	


	private static FreeLockSingleton instance = null;


	private static AtomicBoolean createInstanceCertificate = new AtomicBoolean();


	public static void main(String[] args) {


		ExecutorService executorService = Executors.newCachedThreadPool();


		for (int i = 0; i < 10; i++) {


			executorService.submit(new Runnable() {


				@Override
				public void run() {


					FreeLockSingleton.getInstance();


				}
			});
		}


		executorService.shutdown();
	}
}