首页 文章 精选 留言 我的

精选列表

搜索[并发原语]，共10000篇文章
优秀的个人博客,低调大师

python并发模块之concurrent.futures(一)

Python3.2开始，标准库为我们提供了concurrent.futures模块，它提供了ThreadPoolExecutor和ProcessPoolExecutor两个类，实现了对threading和multiprocessing的进一步抽象，对编写线程池/进程池提供了直接的支持,他属于上层的封装，对于用户来说，不用在考虑那么多东西了。 官方参考资料:https://pythonhosted.org/futures/ 1.Executor Exectuor是基础模块，这是一个抽象类，其子类分为ThreadPoolExecutor和ProcessPoolExecutor，分别被用来创建线程池和进程池。 提供的方法如下： Executor.submit(fn, *args, **kwargs) fn:为需要异步执行的函数 args,kwargs:为给函数传递的参数 就来看看官网的这个例子: withThreadPoolExecutor(max_workers=1)asexecutor: future=executor.submit(pow,323,1235) print(future.result()) 我们使用submit方法来往线程池中加入一个task(pow函数)，submit返回一个Future对象。其中future.result()的result方法的作用是拿到调用返回的结果。如果没有执行完毕就会去等待。这里我们使用with操作符，使得当任务执行完成之后，自动执行shutdown函数，而无需编写相关释放代码。 关于更多future的具体方法说明看后面的future部分解释。 Executor.map(fn, *args, **kwargs) map(func, *iterables, timeout=None) 此map函数和python自带的map函数功能类似，只不过concurrent模块的map函数从迭代器获得参数后异步执行。并且，每一个异步操作，能用timeout参数来设置超时时间，timeout的值可以是int或float型，如果操作timeout的话，会raisesTimeoutError。如果timeout参数不指定的话，则不设置超时间。 func：为需要异步执行的函数 iterables：可以是一个能迭代的对象. timeout：设置每次异步操作的超时时间 fromconcurrent.futuresimportThreadPoolExecutorimportrequests URLS=['http://www.163.com','https://www.baidu.com/','https://github.com/']defload_url(url): req=requests.get(url,timeout=60) print('%rpageis%dbytes'%(url,len(req.content))) executor=ThreadPoolExecutor(max_workers=3) executor.map(load_url,URLS) print('主线程结束') submit函数和map函数，根据需要，选一个使用即可。 Executor.shutdown(wait=True) 此函数用于释放异步执行操作后的系统资源。Executor实现了enter__和__exit使得其对象可以使用with操作符。 在这里可以使用with上下文关键字代替，如上面第一个submit的例子。 2.Future对象 submit函数返回future对象，future提供了跟踪任务执行状态的方法,Future实例可以被Executor.submit()方法创建。除了测试之外不应该直接创建。 cancel()：尝试去取消调用。如果调用当前正在执行，不能被取消。这个方法将返回False，否则调用将会被取消，方法将返回True cancelled()：如果调用被成功取消返回True running()：如果当前正在被执行不能被取消返回True done()：如果调用被成功取消或者完成running返回True result(Timeout = None)：拿到调用返回的结果。如果没有执行完毕就会去等待 exception(timeout=None)：捕获程序执行过程中的异常 add_done_callback(fn)：将fn绑定到future对象上。当future对象被取消或完成运行时，fn函数将会被调用 3.wait方法 wait方法接会返回一个tuple(元组)，tuple中包含两个set(集合)，一个是completed(已完成的)另外一个是uncompleted(未完成的)。使用wait方法的一个优势就是获得更大的自由度，它接收三个参数FIRST_COMPLETED, FIRST_EXCEPTION 和ALL_COMPLETE，默认设置为ALL_COMPLETED。 如果采用默认的ALL_COMPLETED，程序会阻塞直到线程池里面的所有任务都完成，再执行主线程： #!/usr/bin/envpython#encoding:utf-8fromconcurrent.futuresimportThreadPoolExecutor,wait,as_completedimportrequests URLS=['http://www.163.com','https://www.baidu.com/','https://github.com/']defload_url(url): req=requests.get(url,timeout=60) print('%rpageis%dbytes'%(url,len(req.content))) executor=ThreadPoolExecutor(max_workers=3) f_list=[]forurlinURLS: future=executor.submit(load_url,url) f_list.append(future) print(wait(f_list)) print('主线程结束') 如果采用FIRST_COMPLETED参数，程序并不会等到线程池里面所有的任务都完成。 fromconcurrent.futuresimportThreadPoolExecutor,wait,as_completedimportrequests URLS=['http://www.163.com','https://www.baidu.com/','https://github.com/']defload_url(url): req=requests.get(url,timeout=60) print('%rpageis%dbytes'%(url,len(req.content))) executor=ThreadPoolExecutor(max_workers=3) f_list=[]forurlinURLS: future=executor.submit(load_url,url) f_list.append(future) print(wait(f_list,return_when='FIRST_COMPLETED')) print('主线程结束') 关于模块的基本使用就是上面的这些。后续会做一些拓展或者案例。
2019-03-19
优秀的个人博客,低调大师

Java并发编程之线程安全、线程通信

Java多线程开发中最重要的一点就是线程安全的实现了。所谓Java线程安全，可以简单理解为当多个线程访问同一个共享资源时产生的数据不一致问题。为此，Java提供了一系列方法来解决线程安全问题。 synchronized synchronized用于同步多线程对共享资源的访问，在实现中分为同步代码块和同步方法两种。 同步代码块 1 public class DrawThread extends Thread { 2 3 private Account account; 4 private double drawAmount; 5 public DrawThread(String name, Account account, double drawAmount) { 6 super(name); 7 this.account = account; 8 this.drawAmount = drawAmount; 9 } 10 @Override 11 public void run() { 12 //使用account作为同步代码块的锁对象 13 synchronized(account) { 14 if (account.getBalance() >= drawAmount) { 15 System.out.println(getName() + "取款成功, 取出:" + drawAmount); 16 try { 17 TimeUnit.MILLISECONDS.sleep(1); 18 } catch (InterruptedException e) { 19 e.printStackTrace(); 20 } 21 account.setBalance(account.getBalance() - drawAmount); 22 System.out.println("余额为: " + account.getBalance()); 23 } else { 24 System.out.println(getName() + "取款失败!余额不足!"); 25 } 26 } 27 } 28 } 同步方法 使用同步方法，即使用synchronized关键字修饰类的实例方法或类方法，可以实现线程安全类，即该类在多线程访问中，可以保证可变成员的数据一致性。 同步方法中，隐式的锁对象由锁的是实例方法还是类方法确定，分别为该类对象或类的Class对象。 1 public class SyncAccount { 2 private String accountNo; 3 private double balance; 4 //省略构造器、getter setter方法 5 //在一个简单的账户取款例子中, 通过添加synchronized的draw方法, 把Account类变为一个线程安全类 6 public synchronized void draw(double drawAmount) { 7 if (balance >= drawAmount) { 8 System.out.println(Thread.currentThread().getName() + "取款成功, 取出:" + drawAmount); 9 try { 10 TimeUnit.MILLISECONDS.sleep(1); 11 } catch (InterruptedException e) { 12 e.printStackTrace(); 13 } 14 balance -= drawAmount; 15 System.out.println("余额为: " + balance); 16 } else { 17 System.out.println(Thread.currentThread().getName() + "取款失败!余额不足!"); 18 } 19 } 20 //省略HashCode和equals方法 21 } 同步锁（Lock、ReentrantLock） Java5新增了两个用于线程同步的接口Lock和ReadWriteLock，并且分别提供了两个实现类ReentrantLock(可重入锁)和ReentrantReadWriteLock(可重入读写锁)。 相比较synchronized，ReentrantLock的一些优势功能： 1. 等待可中断：指持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待。 2. 公平锁：多个线程等待同一个锁时，必须按照申请锁的时间顺序依次获取。synchronized是非公平锁，ReentrantLock可以通过参数设置为公平锁 3. 多条件锁：ReentrantLock可通过Condition类获取多个条件关联 Java 1.6以后，synchronized性能提升较大，因此一般的开发中依然建议使用语法层面上的synchronized加锁。 Java8新增了更为强大的可重入读写锁StampedLock类。 比较常用的是ReentrantLock类，可以显示地加锁、释放锁。下面使用ReentrantLock重构上面的SyncAccount类。 1 public class RLAccount { 2 //定义锁对象 3 private final ReentrantLock lock = new ReentrantLock(); 4 private String accountNo; 5 private double balance; 6 //省略构造方法和getter setter 7 public void draw(double drawAmount) { 8 //加锁 9 lock.lock(); 10 try { 11 if (balance >= drawAmount) { 12 System.out.println(Thread.currentThread().getName() + "取款成功, 取出:" + drawAmount); 13 try { 14 TimeUnit.MILLISECONDS.sleep(1); 15 } catch (InterruptedException e) { 16 e.printStackTrace(); 17 } 18 balance -= drawAmount; 19 System.out.println("余额为: " + balance); 20 } else { 21 System.out.println(Thread.currentThread().getName() + "取款失败!余额不足!"); 22 } 23 } finally { 24 //通过finally块保证释放锁 25 lock.unlock(); 26 } 27 } 28 } 死锁 当两个线程相互等待地方释放锁的时候，就会产生死锁。关于死锁和线程安全的深入分析，将另文介绍。 线程通信方式之wait、notify、notifyAll Object类提供了三个用于线程通信的方法，分别是wait、notify和notifyAll。这三个方法必须由同步锁对象来调用，具体来说： 1. 同步方法：因为同步方法默认使用所在类的实例作为锁，即this，可以在方法中直接调用。 2. 同步代码块：必须由锁来调用。 wait()：导致当前线程等待，直到其它线程调用锁的notify方法或notifyAll方法来唤醒该线程。调用wait的线程会释放锁。 notify()：唤醒任意一个在等待的线程 notifyAll()：唤醒所有在等待的线程 1 /* 2 * 通过一个生产者-消费者队列来说明线程通信的基本使用方法 3 * 注意: 假如这里的判断条件为if语句，唤醒方法为notify, 那么如果分别有多个线程操作入队\出队, 会导致线程不安全. 4 */ 5 public class EventQueue { 6 7 private final int max; 8 9 static class Event{ 10 11 } 12 //定义一个不可改的链表集合, 作为队列载体 13 private final LinkedList<Event> eventQueue = new LinkedList<>(); 14 15 private final static int DEFAULT_MAX_EVENT = 10; 16 17 public EventQueue(int max) { 18 this.max = max; 19 } 20 21 public EventQueue() { 22 this(DEFAULT_MAX_EVENT); 23 } 24 25 private void console(String message) { 26 System.out.printf("%s:%s\n",Thread.currentThread().getName(), message); 27 } 28 //定义入队方法 29 public void offer(Event event) { 30 //使用链表对象作为锁 31 synchronized(eventQueue) { 32 //在循环中判断如果队列已满, 则调用锁的wait方法, 使线程阻塞 33 while(eventQueue.size() >= max) { 34 try { 35 console(" the queue is full"); 36 eventQueue.wait(); 37 } catch (InterruptedException e) { 38 e.printStackTrace(); 39 } 40 } 41 console(" the new event is submitted"); 42 eventQueue.addLast(event); 43 this.eventQueue.notifyAll(); 44 } 45 } 46 //定义出队方法 47 public Event take() { 48 //使用链表对象作为锁 49 synchronized(eventQueue) { 50 //在循环中判断如果队列已空, 则调用锁的wait方法, 使线程阻塞 51 while(eventQueue.isEmpty()) { 52 try { 53 console(" the queue is empty."); 54 eventQueue.wait(); 55 } catch (InterruptedException e) { 56 e.printStackTrace(); 57 } 58 } 59 Event event = eventQueue.removeFirst(); 60 this.eventQueue.notifyAll(); 61 console(" the event " + event + " is handled/taked."); 62 return event; 63 } 64 } 65 } 线程通信方式之Condition 如果使用的是Lock接口实现类来同步线程，就需要使用Condition类的三个方法实现通信，分别是await、signal和signalAll，使用上与Object类的通信方法基本一致。 1 /* 2 * 使用Lock接口和Condition来实现生产者-消费者队列的通信 3 */ 4 public class ConditionEventQueue { 5 //显示定义Lock对象 6 private final Lock lock = new ReentrantLock(); 7 //通过newCondition方法获取指定Lock对象的Condition实例 8 private final Condition cond = lock.newCondition(); 9 private final int max; 10 static class Event{ } 11 //定义一个不可改的链表集合, 作为队列载体 12 private final LinkedList<Event> eventQueue = new LinkedList<>(); 13 private final static int DEFAULT_MAX_EVENT = 10; 14 public ConditionEventQueue(int max) { 15 this.max = max; 16 } 17 18 public ConditionEventQueue() { 19 this(DEFAULT_MAX_EVENT); 20 } 21 22 private void console(String message) { 23 System.out.printf("%s:%s\n",Thread.currentThread().getName(), message); 24 } 25 //定义入队方法 26 public void offer(Event event) { 27 lock.lock(); 28 try { 29 //在循环中判断如果队列已满, 则调用cond的wait方法, 使线程阻塞 30 while (eventQueue.size() >= max) { 31 try { 32 console(" the queue is full"); 33 cond.await(); 34 } catch (InterruptedException e) { 35 e.printStackTrace(); 36 } 37 } 38 console(" the new event is submitted"); 39 eventQueue.addLast(event); 40 cond.signalAll();; 41 } finally { 42 lock.unlock(); 43 } 44 45 } 46 //定义出队方法 47 public Event take() { 48 lock.lock(); 49 try { 50 //在循环中判断如果队列已空, 则调用cond的wait方法, 使线程阻塞 51 while (eventQueue.isEmpty()) { 52 try { 53 console(" the queue is empty."); 54 cond.wait(); 55 } catch (InterruptedException e) { 56 e.printStackTrace(); 57 } 58 } 59 Event event = eventQueue.removeFirst(); 60 cond.signalAll(); 61 console(" the event " + event + " is handled/taked."); 62 return event; 63 } finally { 64 lock.unlock(); 65 } 66 } 67 } Java 1.5开始就提供了BlockingQueue接口，来实现如上所述的生产者-消费者线程同步工具。具体介绍将另文说明。
2018-11-06
优秀的个人博客,低调大师

（十五）Java并发性和多线程-死锁

死锁是两个或更多线程阻塞着等待其它处于死锁状态的线程所持有的锁。死锁通常发生在多个线程同时但以不同的顺序请求同一组锁的时候。 例如，如果线程1锁住了A，然后尝试对B进行加锁，同时线程2已经锁住了B，接着尝试对A进行加锁，这时死锁就发生了。线程1永远得不到B，线程2也永远得不到A，并且它们永远也不会知道发生了这样的事情。为了得到彼此的对象（A和B），它们将永远阻塞下去。这种情况就是一个死锁。 该情况如下： Thread 1 locks A, waits for B Thread 2 locks B, waits for A 一个简单的死锁类 当DeadLock类的对象flag==1时（td1），先锁定o1,睡眠500毫秒 而td1在睡眠的时候另一个flag==0的对象（td2）线程启动，先锁定o2,睡眠500毫秒 td1睡眠结束后需要锁定o2才能继续执行，而此时o2已被td2锁定； td2睡眠结束后需要锁定o1才能继续执行，而此时o1已被td1锁定； td1、td2相互等待，都需要得到对方锁定的资源才能继续执行，从而死锁。 import lombok.extern.slf4j.Slf4j; @Slf4j public class DeadLock implements Runnable { public int flag = 1; //静态对象是类的所有对象共享的 private static Object o1 = new Object(), o2 = new Object(); @Override public void run() { log.info("flag:{}", flag); if (flag == 1) { synchronized (o1) { try { Thread.sleep(500); } catch (Exception e) { e.printStackTrace(); } synchronized (o2) { log.info("1"); } } } if (flag == 0) { synchronized (o2) { try { Thread.sleep(500); } catch (Exception e) { e.printStackTrace(); } synchronized (o1) { log.info("0"); } } } } public static void main(String[] args) { DeadLock td1 = new DeadLock(); DeadLock td2 = new DeadLock(); td1.flag = 1; td2.flag = 0; //td1,td2都处于可执行状态，但JVM线程调度先执行哪个线程是不确定的。 //td2的run()可能在td1的run()之前运行 new Thread(td1).start(); new Thread(td2).start(); } }
2018-08-15
优秀的个人博客,低调大师

GO------小白之并发聊天室

因为没有写客户端、可以在cmd中利用 nc -u 来充当客户端 广播用户上线： 1、主go程中创建socket、defer 2、循环监听客户端连接请求 3、有一个客户端链接、创建新go程处理客户数据 4、组织用户相关信息、全局变量（结构体、map、channel） 5、Hadlconn、初始化新用户结构体信息、获取客户端IP和port、初始化新用户结构体信息、 name==addr 6、创建manager管理go程、要在for循环accpet之前、实现manager、初始化在线用户map.循环读取全局的channel、如果无数据阻塞、如果有数据遍历在线用户 map、将数据写到用户的channel中 7、新用户添加到map中、key==ip+port value==结构体 8、创建WriteToClient go程专门给当前用户发送消息、遍历自带C、读数据、Conn.Write写到客户端 9、Hadlconn中。结束位置、组织用户上线信息、将用户上线信息写到全局channel--Maneger被激 活 10、Hadlconn结尾处要有for循环、不然直接终止 有问题的地方都已经注释 接下来要在基础框架上增加小功能 发送消息内容： 1、封装函数来广播用户传的消息，传到massage中 2、起匿名go程、主要是来读取客户端发送的内容、写到全局massage中 3、for 循环读取客户端发送的内容 4、写给全局massage 查询在线用户： 将buf里减去一个“\n” 判断是否为who，如果为who、遍历map ，将名字利用conn.Write写到当前客户端 修改用户名： 1、将读取到的masg进行判断是否为rename 2、提取rename| 后的字符串、存入到client.name成员中 3、更新在线用户列表 onlinemap--key-----ip+port 4、提示用户更新成功 用户退出： 1、在用户登录成功后、创建监听用户退出的channel---isQuit 2、当conn.read==0时、isQuit<-true 3、在handleConnect结尾for中、添加select监听<-isQuit 4、条件满足、将用户从在线列表移除、阻止用户下线消息、写入massage通道 超时强踢： 1、在select中添加监听定时器time.After，计时到达将用户从在线列表移除、阻止用户下线消息、写入 massage通道 2、判断用户是否活跃，创建监听活跃的channel、只要用户执行聊天改名查询任意操作，向此channel 写数据 3、在select添加用户活跃度的监听、条件满足、不作为，目的是重置上面创建的计时器 这些功能其实都是在HandleConn函数中实现的 Func HandleConn(connnet.Conn){ defer conn.Close() //初始化结构体 addr:=conn.RemoteAddr().String() client:=Client{make(chanstring),addr,addr} Olinemap[addr]=client msg:=Mkmas(client,"login") //将消息传到全局通道发送给其他人 goWriteToClient(client,conn) Massage<-msg quit:=make(chanbool) datahas:=make(chanbool) //匿名函数主要做的是客户端写入的数据 buf:=make([]byte,1024) go func() { for{ n,err:=conn.Read(buf) ifn==0{ quit<-true fmt.Println("客户端退出") return } iferr!=nil{ fmt.Println("conn.Read error",err) return } msg:=string(buf[:n-1]) ifmsg=="who"&&len(msg)==3{ conn.Write([]byte("user list:")) for_,value:=rangeOlinemap{ Massage<-value.Addr+value.Name } }else iflen(msg)>=8&&msg[:6]=="rename"{ newname:=msg[7:] client.Name=newname Olinemap[addr]=client Olinemap[addr].Name=msg[7:,go语言里不支持这样修改结构体中的数据 conn.Write([]byte("rename successfully")) }else{ info:=Mkmas(client,msg) Massage<-info } datahas<-true //注意位置、如果客户端改名、who命令都算活跃 } }() for{ select{ case<-quit: //确定退出、n==0时 close(client.C) //关闭WriteToClient函数 delete(Olinemap,addr) str:=Mkmas(client,"exit") fmt.Println(str,"exit") Massage<-str return //return当前go程返回、但是中间创建的go程不会停止。所以要将WriteToClient关闭 case<-datahas: //如果客户端活跃则不做操作，这个是为了让下面的超时退出重置 case<-time.After(time.Second*10): delete(Olinemap,addr) str:=Mkmas(client,"timeout") Massage<-str fmt.Println(str,"timeout") return } } }
2018-08-13
优秀的个人博客,低调大师

（二）Java并发学习笔记--安全发布对象

逸出的方式 上边关于逸出的概念讲述的很是模糊，下面列举几个逸出的示例。 通过静态变量引用逸出 public static Set<Secret> knownSecrets; public void initialize() { knowsSecrets = new HashSet<Secret>(); } 上边代码示例中，调用initialize方法，发布了knowSecrets对象。当你向knowSecrets中添加一个Secret时，会同时将Secret对象发布出去，原因是可以通过遍历knowSecrets获取到Secret对象的引用，然后进行修改。 通过非静态（私有）方法 class UnsafeStates { private String[] states = new String[]{"AK", "AL"}; public String[] getStates() { return states; } } 以这种方式发布的states会出问题，任何一个调用者都能修改它的内容。数组states已经逸出了它所属的范围，这个本应该私有的数据，事实上已经变成共有的了。 this逸出 public class ThisEscape { public ThisEscape(EventSource source) { source.registerListener(new EventListener() { public void onEvent(Event e) { doSomething(e); } }); } } 在上边代码中，当我们实例化ThisEscape对象时，会调用source的registerListener方法时，便启动了一个线程，而且这个线程持有了ThisEscape对象（调用了对象的doSomething方法），但此时ThisEscape对象却没有实例化完成（还没有返回一个引用），所以我们说，此时造成了一个this引用逸出，即还没有完成的实例化ThisEscape对象的动作，却已经暴露了对象的引用，使其他线程可以访问还没有构造好的对象，可能会造成意料不到的问题。 通过上述示例，个人理解，对逸出的概念应该定义为： 一个对象，超出了它原本的作用域，而可以被其它对象进行修改，而这种修改及修改的结果是无法预测的。换句话说：一个对象发布后，它的状态应该是稳定的，修改是可被检测到的。如果在其它线程修改（或做其它操作）一个对象后导致对象的状态未知，就可以说这个对象逸出了。 总之，一个对象逸出后，不论其它线程或对象是否使用这个逸出的对象都不重要，重要的是，被误用及被误用后的未知结果的风险总是存在的。 PS 书中给出了避免this逸出的方法： public class SafeListener { private final EventListener listener; private SafeListener() { listener = new EventListener() { public void onEvent(Event e) { doSomething(e); } }; } public static SafeListener newInstance(EventSource source) { SafeListener safe = new SafeListener(); source.registerListener(safe.listener); return safe; } } 在这个构造中，我们看到的最大的一个区别就是：当构造好了SafeListener对象之后，我们才启动了监听线程，也就确保了SafeListener对象是构造完成之后在使用的SafeListener对象。 对于这样的技术，书里面也有这样的注释： 具体来说，只有当构造函数返回时，this引用才应该从线程中逸出。构造函数可以将this引用保存到某个地方，只要其他线程不会在构造函数完成之前使用它。 安全发布对象 在静态初始化函数中初始化一个对象引用 将对象的应用保存到volatile类型的域或者AtomicReferance对象中 将对象的引用保存到某个正确构造对象的final类型域中 将对象的引用保存到一个由锁保护的域中。 /** * 懒汉模式（线程不安全） * 单例实例在第一次使用时进行创建 */ @NotThreadSafe public class SingletonExample1 { // 私有构造函数 private SingletonExample1() { } // 单例对象 private static SingletonExample1 instance = null; // 静态的工厂方法 public static SingletonExample1 getInstance() { // 这里同时有两个线程进入就可能同时初始化两个对象 if (instance == null) { instance = new SingletonExample1(); } return instance; } } 懒汉模式本身是线程不安全的，如果想要实现线程安全可以通过synchronized关键字实现： /** * 懒汉模式 * 单例实例在第一次使用时进行创建 */ @ThreadSafe @NotRecommend public class SingletonExample3 { // 私有构造函数 private SingletonExample3() { } // 单例对象 private static SingletonExample3 instance = null; // 静态的工厂方法 public static synchronized SingletonExample3 getInstance() { if (instance == null) { instance = new SingletonExample3(); } return instance; } } 但此中方式不推荐使用，应该它通过同一时间内只允许一个线程来访问的方式实现线程安全，但是却带来了性能上面的开销。 我们可以通过以下方式来实现线程安全： 懒汉模式 -》 volatile + 双重同步锁单例模式 /** * 懒汉模式 -》 双重同步锁单例模式 * 单例实例在第一次使用时进行创建 */ @ThreadSafe public class SingletonExample4 { // 私有构造函数 private SingletonExample4() { } // 1、memory = allocate() 分配对象的内存空间 // 2、ctorInstance() 初始化对象 // 3、instance = memory 设置instance指向刚分配的内存 // JVM和cpu优化，发生了指令重排（多线程 ） // 1、memory = allocate() 分配对象的内存空间 // 3、instance = memory 设置instance指向刚分配的内存 // 2、ctorInstance() 初始化对象 // 单例对象 volatile + 双重检测机制 -> 禁止指令重排 private volatile static SingletonExample4 instance = null; public static SingletonExample4 getInstance() { if (instance == null) { // 双重检测机制 // B synchronized (SingletonExample4.class) { // 同步锁 if (instance == null) { instance = new SingletonExample4(); // A - 3 } } } return instance; } } /** * 饿汉模式 * 单例实例在类装载时进行创建 */ @ThreadSafe public class SingletonExample2 { // 私有构造函数 private SingletonExample2() { } // 单例对象 private static SingletonExample2 instance = new SingletonExample2(); // 静态的工厂方法 public static SingletonExample2 getInstance() { return instance; } } 饿汉模式不会有线程问题，但是在类加载时实例化对象。使用时要考虑两点： 私有构造函数在使用时没有过多的逻辑处理（销毁性能，慢） 这个对象一定会被使用（浪费资源） 在静态代码块中实例化一个对象： /** * 饿汉模式 * 单例实例在类装载时进行创建 */ @ThreadSafe public class SingletonExample6 { // 私有构造函数 private SingletonExample6() { } // 单例对象 private static SingletonExample6 instance = null; static { instance = new SingletonExample6(); } // 静态的工厂方法 public static SingletonExample6 getInstance() { return instance; } public static void main(String[] args) { System.out.println(getInstance().hashCode()); System.out.println(getInstance().hashCode()); } } 枚举模式： /** * 枚举模式：最安全 */ @ThreadSafe @Recommend public class SingletonExample7 { // 私有构造函数 private SingletonExample7() { } public static SingletonExample7 getInstance() { return Singleton.INSTANCE.getInstance(); } private enum Singleton { INSTANCE; private SingletonExample7 singleton; // JVM保证这个方法绝对只调用一次 Singleton() { singleton = new SingletonExample7(); } public SingletonExample7 getInstance() { return singleton; } } }
2018-08-13

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

时间: 2026-10-18 大小: 211.28KB 下载: 56次
腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

时间: 2026-08-21 大小: 1MB 下载: 10次
Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

时间: 2026-08-21 大小: 9.84MB 下载: 40次
WebStorm

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。

时间: 2025-12-13 大小: 249.54MB 下载: 22次
热门标签
DeepSeek Jdk25 OpenAi HarmonyOS6 Nacos3 SpringBoot4 SpringCloud Docker Kubernetes Service Mesh Redis Gemini3 Rocky

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册