Java多线程编程核心技术---单例模式与多线程
立即加载/饿汉模式
立即加载就是使用类的时候已经将对象创建完毕。
public class MyObject {
//立即加载方式==饿汉模式
private static MyObject myObject = new MyObject();
private MyObject(){
}
public static MyObject getInstance(){
//立即加载
//缺点是不能有其他实例变量
//getInstance()方法没有同步，有可能出现非线程安全问题
return myObject;
}
}
public class MyThread extends Thread {
@Override
public void run() {
System.out.println(MyObject.getInstance().hashCode());
}
}
public class Main {
public static void main(String[] args) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
t1.start();
t2.start();
t3.start();
}
}
运行程序，控制台打印结果如下：
1795478472
1795478472
1795478472
控制台打印的hashCode是同一个值，说明对象是同一个，也就实现了立即加载型单例模式。
延迟加载/懒汉模式
延迟加载就是在调用get()方法时实例才被创建
public class MyObject {
private static MyObject myObject;
private MyObject(){
}
public static MyObject getInstance() {
//延迟加载
if (myObject != null) {
return myObject;
}
myObject = new MyObject();
return myObject;
}
}
public class MyThread extends Thread {
@Override
public void run() {
System.out.println(MyObject.getInstance().hashCode());
}
}
public class Main {
public static void main(String[] args) {
MyThread t1 = new MyThread();
t1.start();
}
}
程序运行结果如下：
1396452035
此实验虽然取得一个对象的实例，但是如果是在多线程环境中，就会出现取出多个实例的情况。对以上代码中的main函数做如下修改：
public class Main {
public static void main(String[] args) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
t1.start();
t2.start();
t3.start();
}
}
重新运行程序，控制台打印结果如下：
166471260
1795478472
1858758426
控制台打印了三个不同的hashCode，说明并没有实现单例模式。
延迟加载/懒汉模式 解决方案
public class MyObject {
private static MyObject myObject;
private MyObject(){
}
//整个方法上锁，效率较低
synchronized public static MyObject getInstance() {
//延迟加载
if (myObject != null) {
return myObject;
}
try {
//模拟一些耗时操作
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
myObject = new MyObject();
return myObject;
}
}
重新运行程序，控制台将打印出三个一样的hashCode。
以上方法对整个方法加锁，效率比较低。对以上代码做如下修改：
public class MyObject {
private static MyObject myObject;
private MyObject(){
}
public static MyObject getInstance() {
//延迟加载
if (myObject != null) {
return myObject;
}
try {
//模拟一个耗时操作
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (MyObject.class) {
myObject = new MyObject();
}
return myObject;
}
}
重新运行程序，控制台打印结果如下：
774088025
641502649
1367113803
以上代码虽然解决的效率问题，但是仍然没有保证只创建一个实例。继续对以上代码做如下修改：
public class MyObject {
private static MyObject myObject;
private MyObject(){
}
public static MyObject getInstance() {
//延迟加载
if (myObject != null) {
return myObject;
}
try {
//模拟一个耗时操作
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (MyObject.class) {
if (myObject == null) {
myObject = new MyObject();
}
}
return myObject;
}
}
重新运行程序，控制台输入结果如下：
641502649
641502649
641502649
使用双重检查锁(DCL)功能，成功解决了懒汉模式遇到的多线程问题。DCL也是大多数多线程结合单例模式使用的解决方案。
使用静态内置类实现单例模式
public class MyObject {
private static class MyObjectHandler{
private static MyObject myObject = new MyObject();
}
private MyObject(){
}
public static MyObject getInstance () {
return MyObjectHandler.myObject;
}
}
运行程序，控制台输出结果如下：
774088025
774088025
774088025
序列化与反序列化的单例模式实现
public class MyObject implements Serializable {
private static final long serialVersionUID = 1L;
private static class MyObjectHandler{
private static MyObject myObject = new MyObject();
}
private MyObject(){
}
public static MyObject getInstance () {
return MyObjectHandler.myObject;
}
}
public class SaveAndRead {
public static void main(String[] args) {
try {//序列化对象到磁盘
MyObject myObject = MyObject.getInstance();
FileOutputStream fileOutputStream = new FileOutputStream(new File("/Users/shangyidong/Downloads/myObjectFile.txt"));
ObjectOutputStream objectOutput = new ObjectOutputStream(fileOutputStream);
objectOutput.writeObject(myObject);
objectOutput.close();
fileOutputStream.close();
System.out.println(myObject.hashCode());
} catch (Exception e) {
e.printStackTrace();
}
/****************/
try {//从磁盘反序列化到对象
FileInputStream fileInputStream = new FileInputStream(new File("/Users/shangyidong/Downloads/myObjectFile.txt"));
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
MyObject myObject = (MyObject) objectInputStream.readObject();
objectInputStream.close();
fileInputStream.close();
System.out.println(myObject.hashCode());
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行程序，控制台打印结果如下：
988487739
1878277481
控制台打印出的hashCode不同，存储到磁盘上的对象和从磁盘读取出来的对象并不是同一个对象。对以上代码做如下修改：
public class MyObject implements Serializable {
private static final long serialVersionUID = 1L;
private static class MyObjectHandler{
private static MyObject myObject = new MyObject();
}
private MyObject(){
}
public static MyObject getInstance () {
return MyObjectHandler.myObject;
}
protected Object readResolve(){
System.out.println("readResolve invoked");
return MyObjectHandler.myObject;
}
}
重新运行程序，控制台打印结果如下：
1066557918
readResolve invoked
1066557918
反序列化时使用了ReadResolve()方法，存储到磁盘上的对象和从磁盘上取出来的对象是同一个对象。
使用static代码块实现单例模式
静态代码块中的代码在使用类的时候就已经执行了，所以可以应用静态代码块的这个特性来实现单例模式。
public class MyObject {
private static MyObject myObject = null;
private MyObject(){
}
static{
myObject = new MyObject();
}
public static MyObject getInstance() {
return myObject;
}
}
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(MyObject.getInstance().hashCode());
}
}
}
public class Main {
public static void main(String[] args) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
t1.start();
t2.start();
t3.start();
}
}
运行程序，控制台输出结果如下：
708252873
708252873
708252873
708252873
708252873
708252873
708252873
708252873
708252873
使用enum枚举数据类型实现单例模式
枚举enum和静态代码块的特性相似，在使用枚举类时，构造方法会被自动调用，也可以实现单例设计模式。
public enum MyObject {
connectionFactory;
private Connection connection;
private MyObject(){
try {
System.out.println("创建MyObject对象");
String url = "jdbc:mysql://127.0.0.1:3306/test";
String user = "root";
String password = "";
String driver = "com.mysql.jdbc.Driver";
Class.forName(driver);
connection = DriverManager.getConnection(url, user, password);
} catch (Exception e) {
e.printStackTrace();
}
}
public Connection getConnection() {
return connection;
}
}
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(MyObject.connectionFactory.getConnection().hashCode());
}
}
}
public class Main {
public static void main(String[] args) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
t1.start();
t2.start();
t3.start();
}
}
运行程序，控制台打印结果如下：
创建MyObject对象
1253195928
1253195928
1253195928
1253195928
1253195928
1253195928
1253195928
1253195928
1253195928
完善使用enum枚举实现单例模式
上面的代码中将枚举类进行了暴露，违反了“职责单一原则”。下面进行改善：
public class MyObject {
public enum MyEnumSingleton{
connectionFactory;
private Connection connection;
private MyEnumSingleton(){
try {
System.out.println("创建MyObject对象");
String url = "jdbc:mysql://127.0.0.1:3306/test";
String user = "root";
String password = "";
String driver = "com.mysql.jdbc.Driver";
Class.forName(driver);
connection = DriverManager.getConnection(url, user, password);
} catch (Exception e) {
e.printStackTrace();
}
}
public Connection getConnection() {
return connection;
}
}
public static Connection getConnection() {
return MyEnumSingleton.connectionFactory.getConnection();
}
}
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(MyObject.getConnection().hashCode());
}
}
}
public class Main {
public static void main(String[] args) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
t1.start();
t2.start();
t3.start();
}
}
程序运行结果如下：
创建MyObject对象
2039988480
2039988480
2039988480
2039988480
2039988480
2039988480
2039988480
2039988480
2039988480
Java多线程编程核心技术---单例模式与多线程的更多相关文章
- Java多线程编程核心技术
Java多线程编程核心技术 这本书有利于对Java多线程API的理解,但不容易从中总结规律. JDK文档 1. Thread类 部分源码: public class Thread implements ...
- 《Java 多线程编程核心技术》- 笔记
作为业务开发人员,能够在工作中用到的技术其实不多.虽然平时老是说什么,多线程,并发,注入,攻击!但是在实际工作中,这些东西不见得用得上.因为,我们用的框架已经把这些事做掉了. 比如web开发,外面有大 ...
- Java多线程编程核心技术(三)多线程通信
线程是操作系统中独立的个体,但这些个体如果不经过特殊的处理就不能成为一个整体.线程间的通信就是成为整体的必用方案之一,可以说,使线程间进行通信后,系统之间的交互性会更强大,在大大提高CPU利用率的同时 ...
- Java多线程编程核心技术(二)对象及变量的并发访问
本文主要介绍Java多线程中的同步,也就是如何在Java语言中写出线程安全的程序,如何在Java语言中解决非线程安全的相关问题.阅读本文应该着重掌握如下技术点: synchronized对象监视器为O ...
- Java多线程编程核心技术(一)Java多线程技能
1.进程和线程 一个程序就是一个进程,而一个程序中的多个任务则被称为线程. 进程是表示资源分配的基本单位,线程是进程中执行运算的最小单位,亦是调度运行的基本单位. 举个例子: 打开你的计算机上的任务管 ...
- 《Java多线程编程核心技术》知识梳理
<Java多线程编程核心技术> @author ergwang https://www.cnblogs.com/ergwang/ 文章末尾附pdf和png下载链接 第1章 Java多线程技 ...
- Java多线程编程核心技术---学习分享
继承Thread类实现多线程 public class MyThread extends Thread { @Override public void run() { super.run(); Sys ...
- Java多线程编程核心技术---对象及变量的并发访问（二）
数据类型String的常量池特性 在JVM中具有String常量池缓存的功能. public class Service { public static void print(String str){ ...
- 《Java多线程编程核心技术》推荐
写这篇博客主要是给猿友们推荐一本书<Java多线程编程核心技术>. 之所以要推荐它,主要因为这本书写得十分通俗易懂,以实例贯穿整本书,使得原本抽象的概念,理解起来不再抽象. 只要你有一点点 ...
随机推荐
- selenium+eclispse里代码备注
1.火狐.谷歌和IE浏览器引擎都要重新下载selenium官网引擎,并设置路径才可以支持selenium3 而狐火用自己的引擎不用设置路径既可以支持selenium2也支持selenium3,谷歌和I ...
- 【板子】gcd、exgcd、乘法逆元、快速幂、快速乘、筛素数、快速求逆元、组合数
1.gcd int gcd(int a,int b){ return b?gcd(b,a%b):a; } 2.扩展gcd )extend great common divisor ll exgcd(l ...
- [模板] 2-SAT
昨天早上在准备省队集训,发现自己连2-SAT是什么都不知道,于是一早上都投身于2-SAT模板中,终于有个结果. 思路如下: 1.根据条件表达式建边: 2.缩环: 3.判断是否可行: 4.根据缩完环的图 ...
- 利用iconv进行文件编码批量原地转换
将当前目录及其所有子目录中的以 java 为后缀的文件,从 GB18030 转换为 UTF-8: find . -name "*.java" -exec sh -c " ...
- crawler：简要了解一下PhantomJS
有时,我们需要浏览器处理网页,但并不需要浏览,比如生成网页的截图.抓取网页数据等操作.PhantomJS的功能,就是提供一个浏览器环境的命令行接口,你可以把它看作一个“虚拟浏览器”,除了不能浏览,其他 ...
- ubuntu常见错误--could not get lock /var/lib/dpkg/lock -open
最近研究ubuntu,用apt-get命令安装一些软件包时,总报错:E:could not get lock /var/lib/dpkg/lock -open等 出现这个问题的原因可能是有另外一个程序 ...
- Simultaneous Tag Editing in IntelliJ IDEA 14.1
If you're involved in web development and, for some reason, you haven't given a ride to IntelliJ IDE ...
- A.Kaw矩阵代数初步学习笔记 6. Gaussian Elimination
“矩阵代数初步”(Introduction to MATRIX ALGEBRA)课程由Prof. A.K.Kaw(University of South Florida)设计并讲授. PDF格式学习笔 ...
- html内容写入到文件中的时候出现‘TypeError: expected a character buffer object’错误
代码如下: with open('ryf.md', 'a') as f: f.write(content) # content是html内容 原因是写入文件要求写入内容是str,直接转换成str即可, ...
- opencv 简单模糊和高斯模糊 cvSmooth
cv::Mat 是C++版OpenCV的新结构. cvSmooth() 是老版 C API. 没有把C接口与C + + 结合. 建议你们也可以花一些时间看一下介绍. 同样,你如果查看opencv/mo ...