synchronized

可以将文章内容翻译成中文,广告屏蔽插件可能会导致该功能失效(如失效，请关闭广告屏蔽插件后再试): 问题: What would be the behaviour of the following program where static synchronized method and instance synchronized method is trying to access static field of same class in different threads? Will any thread get blocked? Its very confusing. class MyClass { public static int i = 5; public synchronized void m1() { System.out.println(i); //uses static field i of MyClass //T1 is executing this method } public static synchronized void m3() { //T2 will be able to call this method on same object lock while it is using //static field i??? System.out

线程的notify： 1）要在synchronized代码块或方法里使用 2）唤醒在同一个监视器（synchronized）上的等待线程，如果不止一个线程在此同步监视器等待，则根据调度对策选择唤醒其中一个。只有当前线程放弃对当前同步监视器的锁定后才能执行被唤醒的线程。 线程的wait： 1）要在synchronized代码块或者方法里使用 2）导致当前线程等待，直到其他线程调用该同步监视器的notify()或者notifyAll()方法。 3）wait有三种方法重载。 身为一个小白，最近在学习线程，使用的教材书是《疯狂JAVA讲义》，在做书上课后习题时对wait和notify函数的使用有了进一步，特意写下笔记，小小拙见，如果有什么不对欢迎补充。 首先，需要了解synchronized，一个线程执行同步代码块时，首先要得到对同步监视器的锁定。 整个流程就是“锁定-执行-解锁(释放锁)” 书上的简单问题 一个错误例子： public class Test_1 { public static void main(String args[ ]) { WriteWordThread zhang,wang; zhang=new WriteWordThread("张小红"); //新建线程。 wang=new WriteWordThread("JamsKeven"); //新建线程。 zhang

这两个方法同步吗？ 总结： ①一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其他的线程都只能等待，换句话说，某一时刻内，只能有唯一一个线程去访问这些synchronized方法。 ②锁的是当前对象this，被锁定后，其他线程都不能进入到当前对象的其他的synchronized方法。 ③加个普通方法后发现和同步锁无关。 ④换成静态同步方法后，情况又变化 转载请标明出处: 类级锁与对象锁 文章来源: 类级锁与对象锁

操作简单，以键值对的方式存储在本地。 getSharedPreference在子线程进行读取操作，为啥还会阻塞线程呢? 因为get操作要等所有键值对都读取完毕之后，才能进行操作。 看源码： val sp = getSharedPreferences( "zhen" , Context. MODE_PRIVATE ) val editor = sp.edit() editor.putString( "key" , "value" ) editor.commit() val value = sp.getString( "key" , "null" ) SharedPreferenceImpl SharedPreferencesImpl (File file , int mode) { mFile = file ; mBackupFile = makeBackupFile (file) ; mMode = mode ; mLoaded = false; mMap = null; startLoadFromDisk() ; } 开启子线程进行文件读取 private void startLoadFromDisk () { synchronized ( mLock ) { mLoaded = false; } new Thread( "SharedPreferencesImpl-load"

在操作系统中，正在运行的程序称为进程，进程负责程序内存空间的分配。 进程包含线程，每条线程都是进程中代码的一条执行路径，是进程的实际运作单位。 一个进程中可以并发多个线程，每条线程并行执行不同的任务。 在一个进程中有多个线程同时在执行不同的任务的行为。 一个Java应用程序中至少有两个线程：一个是主线程，负责main方法代码的执行，一个是垃圾回收器线程，负责回收垃圾。 能让一个进程同时执行多个任务，提高资源的利用率（不是效率）。 增加了CPU的负担，降低了一个进程中线程的执行概率。 会引发线程安全问题，出现了死锁现象。 public class Main { public static void main(String[] args) { 1. 继承方式开启线程 Demo1 demo = new Demo1(); demo.start(); 2. 实现接口方式开启线程 Demo2 demo2 = new Demo2(); Thread thread = new Thread(demo2); thread.start(); } } 1. 继承方式开启线程 class Demo1 extends Thread { @Override public void run() { super .run(); } } 2. 实现接口方式开启线程 class Demo2 implements

一直对设计模式很模糊，虽然项目中运用到了，但是很难真正说清什么是设计模式。这一节主要讲的是单例设计模式 在一个类中只有一个类的实例（构造函数是私有的），这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。主要作用对象是：一个全局使用的类频繁地创建与销毁。 /** * @author xieyong * @description 单例设计模式---一个类只有一个实例 * @date 2018/5/29 16:58 * @modified by: */ public class Singleton { private static Singleton singleton; //让构造函数为 private，这样该类就不会被实例化 private Singleton (){} public static Singleton getInstance (){ if ( null ==singleton){ singleton= new Singleton(); } return singleton; } } 这种写法lazy loading很明显，但是致命的是在多线程不能正常工作。　 /** * @author xieyong * @description 单例设计模式---一个类只有一个实例 * @date 2018/5/29 16:58 * @modified

1.创建多线程 public class MultiThread { public static void main(String[] args) { // 通过继承Thread类 Thread thread = new Thread(){ @Override public void run() { while ( true ){ try { Thread.sleep( 500 ); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println( "1:" + Thread.currentThread().getName()); System.out.println( "2:" + this .getName()); } } }; thread.start(); // 通过实现Runnable接口 Thread thread2 = new Thread( new Runnable(){ @Override public void run() { while ( true ){ try { Thread.sleep( 500 ); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println( "1:"

作用：让其他线程能够马上感知到某个线程多某个变量的修改 保证可见性 对共享变量的修改，其他线程能够马上感知到 保证有序性 在重排序时保证volatile修饰的代码位置不变 实现原理 对于volatile修饰的变量会编译时会使用Lock指令，其他线程用到Lock指令修饰的变量时会从主存中直接获取 状态标志（开关模式） 一个线程通过改变共享变量的值，来控制另一个现实的结束 双重检查锁定（double-checked-locking） DCL 懒汉式单例 需要利用顺序性 使用上 volatile修饰变量，synchronized修饰方法和语句块 对原子性的保证 synchronized保证了原子性，volatile不能保证原子性 可见性的保证 都可以保证，但原理不同 volatile对变量加lock，synchronized使用monitorEnter和monitorExit 对有序性的保证 volatile禁止了重排序，保证了有序性 sychronized是通过加重量级锁将并行退化成串行，容易引起阻塞 来源：博客园 作者： YL10000 链接：https://www.cnblogs.com/lifeone/p/11653133.html

类别 synchronized Lock 存在层次 Java的关键字 一个类 锁的释放 1.以获取锁的线程执行代码同步代码，释放锁。 2，线程执行发生异常，jvm会让线程释放锁 在finally中必须释放锁，不然容易造成线程死锁 锁的获取 假设A线程获得锁，B线程等待，如果A线程阻塞，则B会一直等 分情况而定，Lock有多个获取锁的方式，线程不用一直等 锁状态 无法判断 可判断 锁类型 可重入，不可中断，非公平 可重入，可判断，可公平 性能 少量同步 大量同步 1.Lock Lock的几个方法 lock() 获取锁 unlock() 释放锁 trylock() 获得锁的状态，返回true和false tryLock(long time,TimeUnit unit) 比tryLock加了时间期限 lockInterruptibly() 2. synchronized 乐观锁 （ Optimistic Locking ） 相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销，特别是对长事务而言，这样的开销往往无法承受。而乐观锁机制在一定程度上解决了这个问题。乐观锁，大多是基于数据版本（ Version ）记录机制实现。何谓数据版本？即为数据增加一个版本标识

上一篇文章 可见性有序性，Happens-before来搞定 ，解决了并发三大问题中的两个，今天我们就聊聊如何解决原子性问题 原子性问题的源头就是 线程切换 ，但在多核 CPU 的大背景下，不允许线程切换是不可能的，正所谓「魔高一尺，道高一丈」，新规矩来了: 互斥: 同一时刻只有一个线程执行 实际上，上面这句话的意思是: 对共享变量的修改是互斥的，也就是说线程 A 修改共享变量时其他线程不能修改，这就不存在操作被打断的问题了，那么如何实现互斥呢？ 对并发有所了解的小伙伴马上就能想到 锁 这个概念，并且你的第一反应很可能就是使用 synchronized，这里列出来你常见的 synchronized 的三种用法: public class ThreeSync { private static final Object object = new Object (); public synchronized void normalSyncMethod (){ //临界区 } public static synchronized void staticSyncMethod (){ //临界区 } public void syncBlockMethod (){ synchronized ( object ){ //临界区 } } } 三种 synchronized 锁的内容有一些差别: