synchronized

重要的网址 1. https://www.cnblogs.com/charlesblc/p/5994162.html synchronized锁的优化过程很全面 2. https://www.cnblogs.com/skywang12345/ 系列教程 一、什么是synchronized? synchronized 是Java提供的一个并发控制的关键字，作用于对象上。主要有两种用法，分别是同步方法(访问对象和clss对象）和同步代码块（需要加入对象），保证了代码的原子性和可见性以及有序性，但是不会处理重排序以及代码优化的过程，但是在一个线程中执行肯定是有序的，因此是有序的。 二、synchronized的基本原理 原理是借用对象markword中的标记以及monitor监控器生成monitorEnter以及monitorExit指令以及对应的计数器。 三、jdk1.6之后的synchronized 在jdk1.6之前，synchronized是非常重量级的，因为它会无时无刻进行锁住对象，而不考虑到程序实际的竞争情况，大多数程序在都是进行交替执行，也就是说不存在资源的竞争，如果没有竞争，但是加锁，加锁和解锁是非常耗费性能的，（重量级)因为线程之间的切换以及线程从内核态到用户态的时间是耗费性能的。 在jdk1.6之后，sun公司对synchronized进行了大幅度的优化

Netty锁事的五个关键点： ① 在意锁的对象和范围 --> 减少粒度 ② 注意锁的对象本身大小 --> 减少空间占用 ③ 注意锁的速度 --> 提高速度 ④不同场景选择不同的并发类 -->因需而边 ⑤衡量好锁的价值 --> 能不用则不用 接下来按个看看： ①：在Netty的ServerBootstrap中的init()： 上图不难看出来，多处使用了synchronized(){},而并非在inti方法上使用synchronized,如果这么做那么锁的对象就是这个实例，锁的范围则是大括号方法的范围，但是实际上我们不需要这么做，只是把Synchronized method -->Synchronized block，针对上图不同的属性，我们可以分别做锁,这样就减少了锁的范围。 ②：例在ChannelOutboundBuffer中有这样的代码： 　　 这个totalPendingSize是统计待发送的字节数 这样的两个步骤直接使用原子类就能完成，为什么不用原子类而是用了两个较为复杂的方式完成！这里可以参考 https://www.cnblogs.com/-qilin/p/11725861.html ③例记录内存分配字节数等功能用到的LongCounter,在PlatformDependent的newLongCounter()中 上图的代码就是筛选jdk版本然后有不同的返回类型

我们先看个错误示例。代码功能：声明一个数字并赋值10000.然后让1w个线程去减少1，1w个线程去增加1。理论上说，加一万减一万，最后数字的结果并不会改变。 代码： class ErrorDemo{ private static int Num=10000; public static void main(String[] args) throws InterruptedException { int n=10000; //声明线程数组，在后面使用join让主线程等待所有线程执行完。 // 不然主线程跑完了，其他线程没执行完就输出结果会不对的。 Thread[] add=new Thread[n]; Thread[] reduce=new Thread[n]; //创建1w个减少线程 for(int i=0;i<n;i++){ Thread t1=new Thread(){ public void run(){ Num-=1; } }; t1.start(); reduce[i]=t1; } //创建1w个增加线程 for(int i=0;i<n;i++){ Thread t2=new Thread(){ public void run(){ Num+=1; } }; t2.start(); add[i]=t2; } //让主线程等待所有线程执行完毕 for(Thread t

With following class, // This class should be thread-safe!!! class BankAccount { private long balance; // Should it be volatile? synchronized void deposit(long amount) { // ... balance += amount; } synchronized void withdraw(long amount) { // ... balance -= amount; } } Should I add volatile to balance field? No, compared with synchronized keyword, volatile is lightweight. volatile can gurantee the reader thread always get fresh balance value, but it can not make balance += amount; atomic. synchronized can do both. You don’t need volatile in the code shown, because the variable is used only

For my current java exercise, I have to get mail from 2 different gmail accounts. I have done this by creating new instances of my gmail class. The gmail class extends thread, and within it there is a synchronized method readMail() which gets the mail and prints it. This readMail method is called by the run method in a while(true) loop, and then it sleeps for 30 seconds, the idea being that it gets mail every 30 seconds. However, the synchronized method does not seem to work. The threads interrupt each other and the method does not print all the items of a message before the other thread

什么是线程： 线程是进程内的执行单元 某个进程当中都有若干个线程。 线程是进程内的执行单元。 使用线程的原因是，进程的切换是非常重量级的操作，非常消耗资源。如果使用多进程，那么并发数相对来说不会很高。而线程是更细小的调度单元，更加轻量级，所以线程会较为广泛的用于并发设计。 在Java当中线程的概念和操作系统级别线程的概念是类似的。事实上，Jvm将会把Java中的线程映射到操作系统的线程区。 当new出一个线程时，其实线程并没有工作。它只是生成了一个实体，当你调用这个实例的start方法时，线程才真正地被启动。启动后到Runnable状态，Runnable表示该线程的资源等等已经被准备好，已经可以执行了，但是并不表示一定在执行状态，由于时间片轮转，该线程也可能此时并没有在执行。对于我们来说，该线程可以认为已经被执行了，但是是否真实执行，还得看物理cpu的调度。当线程任务执行结束后，线程就到了Terminated状态。 有时候在线程的执行当中，不可避免的会申请某些锁或某个对象的监视器，当无法获取时，这个线程会被阻塞住，会被挂起，到了Blocked状态。如果这个线程调用了wait方法，它就处于一个Waiting状态。进入Waiting状态的线程会等待其他线程给它notify，通知到之后由Waiting状态又切换到Runnable状态继续执行。当然等待状态有两种，一种是无限期等待

今天在实现阻塞队列时，代码抛出了 java.lang.IllegalMonitorStateException 异常。代码如下： public class BlockingQueue_1 { private final List<Object> queue = new LinkedList<>(); private int capacity = 10; public BlockingQueue_1() { } public BlockingQueue_1(int capacity) { this.capacity = capacity; } public synchronized Object put(Object item) throws InterruptedException { while (queue.size() >= capacity) { wait(); } queue.add(item); queue.notifyAll(); return item; } public synchronized void remove() throws InterruptedException { while (0 == queue.size()) { wait(); } queue.remove(0); queue.notifyAll(); } public

问题一：静态与非静态方法是否存在竟态 静态同步方法与非静态同步方法存不存在竟态条件，通俗地说就是分别调用静态同步方法和非静态同步方法的两个线程会不会同步？ 不会，静态方法请求的是类的同步监视器，而非静态方法请求的是实例的monitor。 以下是测试代码： public class TestSynchronized { static final int COUNT = 1000; static synchronized void staticSyn() { for (int i = 0; i < COUNT; i++) { System.out.println("staticSyn " + i); } } synchronized void instanceSyn() { for (int i = 0; i < COUNT; i++) { System.out.println("instanceSyn " + i); } } void blockInstance() { synchronized (this) { for (int i = 0; i < COUNT; i++) { System.out.println("blockInstance " + i); } } } void blockClass() { synchronized (this.getClass()) {

概述 在软件业发展的初期，程序编写都是以算法为核心的，程序员会把数据和过程分别作为独立的部分来考虑，数据代表问题空间中的客体，程序代码则用于处理这些数据，这种思维方式直接站在计算机的角度去抽象问题和解决问题，称为面向过程的编程思想。与此相对的是，面向对象的编程思想是站在现实世界的角度去抽象和解决问题，它把数据和行为都看做是对象的一部分，这样可以让程序员能以符合现实世界的思维方式来编写和组织程序。 面向过程的编程思想极大地提升了现代软件开发的生产效率和软件可以达到的规模，但是现实世界与计算机世界之间不可避免地存在一些差异。例如，人们很难想象现实中的对象在一项工作进行期间，会被不停地中断和切换，对象的属性（数据）可能会在中断期间被修改和变“脏”，而这些事件在计算机世界中则是很正常的事情。有时候，良好的设计原则不得不向现实做出一些让步，我们必须让程序在计算机中正确无误地运行，然后再考虑如何将代码组织得更好，让程序运行得更快。对于这部分的主题“高效并发”来讲，首先需要保证并发的正确性，然后在此基础上实现高效。本章先从如何保证并发的正确性和如何实现线程安全讲起。 线程安全 “线程安全”这个名称，相信稍有经验的程序员都会听说过，甚至在代码编写和走查的时候可能还会经常挂在嘴边，但是如何找到一个不太拗口的概念来定义线程安全却不是一件容易的事情，在Google中搜索它的概念，找到的是类似于

无锁，偏向锁，轻量级锁 ，重量级锁 偏向锁：对象头存储线程ID，可重入（根据线程ID判断） 轻量级锁：复制对象头到Lock Record 记录锁信息，拥有锁 复制的Lock Rrecord 指向对象头 重量级锁：mointer监控 来源： https://www.cnblogs.com/fanBlog/p/11323407.html