synchronized

JDK5以后为代码的同步提供了更加灵活的Lock+Condition模式，并且一个Lock可以绑定多个 Condition对象 1.把原来的使用synchronized修饰或者封装的代码块用lock.lock()与lock.unlock()进行手动的锁获取与释放 //原来的同步方式 synchronized (obj) { ... } //JDK5.0新增的同步方式 //lock.unlock();建议最好要放在finally 执行 try { lock.lock(); ... } finally { lock.unlock(); } 2.把原来线程之间的通讯方式由锁对线obj.wait()和obj.notify()改成了Condition对象的con.await()与con.signal()方法 如下用Lock的方式重写多生产者多消费者模式时， 线程可以指定唤醒生产者或者消费者，这样拥有更高的效率与安全性 package jdk5lockDome; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * @author wpy * */ public

可见性是指：当多个线程访问同一个变量时，某个线程修改了该变量的值，其他线程可以立即看到修改后的变量。当一个共享变量被volatile修饰后，一旦该变量的值被修改，修改后的变量会被理机更新到主存中，当有其他线程需要该变量的值会到主存中读取。 （存在层次）synchronized是JVM实现的，他是java的关键字。lock是java中的接口。 （锁的释放）当出现异常的时候，synchronized会主动释放线程占用的锁，因此不会出现死锁现象。但是lock需要通过unlock( )主动释放占用的锁，因此可能会出现死锁。我们需要在final部分释放占用的锁。 （锁的获取）使用synchronized时，等待锁的线程会一直等待下去不会响应中断，但是使用Lock的线程可以响应中断。 （锁的状态）synchronized无法判断线程是否已经获取了锁；但是Lock可以。 （锁的类型）synchronized的锁是可重入、不可中断、非公平的；Lock是可重入、可中断、可公平的。 可重入指执行对象中的同步方法不用再次获得锁。公平锁指按要获取锁的线程的等待时间分配锁，等待时间越长越有获取锁的优先权。 （锁的性能）Lock可以通过readwriteblock进行读写分离，提升线程的读写效率。当资源竞争不激烈的情形下，synchronized的性能优于Lock，但是当资源竞争激烈时

•1.依靠对象锁锁定 初始化一个对象时，自动有一个 对象锁。 synchronized ｛普通方法｝依靠对象锁工作，多线程访问synchronized方法，一旦某个进程抢得锁之后，其他的进程只有排队对待。 synchronized void method{} 功能上，等效于： void method{ synchronized(this) { 　　　　... } } •2.针对每个类，也有一个锁（作为类的Class对象的一部分）， 所以synchronized static方法可以在类范围内防止对static数据的并发访问。 synchronized ｛static方法} 此代码块等效于： void method{ synchronized(Obj.class) } } 使用该类的 类对象的锁 定去做线程的共享互斥 java编程思想 p677(p713) http://www.cnblogs.com/yanghuahui/p/3365922.html#undefined 来源： https://www.cnblogs.com/ydxblog/p/5594684.html

这里主要涉及到类对象（static方法），对象方法（非static方法） 我们知道，当synchronized修饰一个static方法时，多线程下，获取的是类锁（即Class本身，注意：不是实例）； 当synchronized修饰一个非static方法时，多线程下，获取的是对象锁（即类的实例对象） 所以，当synchronized修饰一个static方法时，创建线程不管是new JoinThread()还是new Thread(new JoinThread())，在run方法中执行inc()方法都是同步的； 相反，当synchronized修饰一个非static方法时，如果用new JoinThread()还是new Thread(new JoinThread())方式创建线程，就无法保证同步操作，因为这时 inc()是属于对象方法，每个线程都执有一个独立的对象实例new JoinThread()，所以多线程下执行inc()方法并不会产生互斥，也不会有同步操作。 另外如果考虑到变更的原子操作，可使用atomic包下面的包装对象，这些对象都是对volatile修饰变量的一种延伸，可保证变量的原子操作而不用去同步方法或 代码块是否同步。 来源： https://www.cnblogs.com/tiancai/p/8204024.html

线程的优先级 线程调度：按照特定的机制为线程分配CPU的时间片段的行为，java程序再运行的时候，由java虚拟机负责线程的调度 线程调度的实现方式：1、分时调度，2、抢占式调度 分时调度：指让所有线程轮流获取CPU的使用权，并为每个线程平均分配CPU的时间片段 抢占式调度：指选择优先级较高的线程执行，如果所有的线程优先级相同，则会随机选择一个线程执行，java虚拟机正是采用这个调度模式。 线程优先级范例一： 1 public class ThreadTest5 { 2 3 public static void main(String[] args) { 4 5 Thread th = new Thread(new Runnable() { 6 @Override 7 public void run() { 8 9 for (int i = 0; i <100 ; i++) { 10 11 System.out.println(Thread.currentThread().getName()); 12 } 13 14 15 } 16 }); 17 th.setPriority(1);//设置该线程的优先级 18 th.start();//开启这个线程，并执行run方法 19 System.out.println(th.getPriority());//获取该线程的优先级 20 21

本篇笔记记录一些在Java多线程编程中常见的关键字，比较简单和基础的就不写太详细了。 一、 Thread类 （其实也是应用了Runnable接口）和 Runnable接口 （只有一个run方法，应用该类必须重写run方法） 一般我们定义一个线程类，可以继承Thread类或者应用Runnable接口，不管是继承哪个，都要重写run方法。 比如我们定义一个线程类： public class Threadtest implements Runnable { @Override void run() { //写你需要这个进程进行的操作 } } 然后在主方法里面生成线程对象并调用start()方法运行： public static void main(String args[]){ new Thread(new Threadtest()).start(); } 一般来说线程有以下几种状态： 新生（New） ：这个状态下我们通过new关键字生成了新的线程Thread对象，为它分配了内存空间，但是这个线程并不是存活状态； 就绪（Runnable） ：线程对象调用start()方法，线程进入runnable状态，等待分配CPU资源。这个时候线程是存活的； 运行（Running） ：获取CPU资源后，线程开始进行，run()方法被执行，直到线程结束，或者因为资源耗尽等原因被中断或挂起； 阻塞

1、同步和异步 比如执行两个方法，同步是指第1个方法执行完返回结果再继续执行第2个方法；而异步是指方法执行不等其结果，另一个方法相继执行，所以结果返回有延迟（ajax调用） 同步特点：保证方法有序的执行，缺点响应慢 异步特点：响应速度快，但不能保证结果有序的执行，如方法1执行时，结果还未返回，方法2已经执行，如果此是需要用方法1的结果作为参数去执行方法2，那么可能程序会报错 2、并发（单个CPU）和并行(多个CPU) 但因CPU执行速度很快，看似都在同时进行，所以一般不作区分 3、临界区 多线程共同访问的共享资源，存在线程安全，所以这个区域需要同步控制 4、阻塞（blocking） 线程挂起 非阻塞(non-blocking) 允许多个线程进入临界区 5、死锁例子（deallock） 1 /** 2 * 死锁例子 3 * 1、两个线程t1,t2 两个资源s1,s2 4 * 2、t1执行 s1资源（已锁），t1休眠2秒, 锁未释放 5 * 3、t2执行 s2资源（已锁） ，继续请求s1资源（已锁） 6 * 4、t1在2秒后继续执行，请求s2资源（已锁） 7 * 5、结果：t1请求s2资源发现s2资源已锁进入等待状态 8 * t2请求s1资源发现s1资源已锁进入等待状态 9 * t1和t2都因等待不能继续执行，进入程序无响应状态 10 * 避免死锁：一个线程避免多个锁

并发 并发在单核和多核 CPU 上都存在, 对于单核 CPU,通过轮训时间片的方式实现并发. 线程 线程对象 利用 Thread 对象, 有两种方式来创建并发程序: 直接创建并管理线程. 当程序要启动一个异步任务的时候, 直接创建一个线程. 将线程管理抽象出来, 把并发部分的任务交给 executor . 线程的创建 有两种方式创建线程: 提供一个实现 Runnable 接口的对象. 子类化 Thread . 两种方法的优缺点? Runnable 总体来说更好一点 使用 Runnable 接口的方式更加灵活, 因为可以继续子类化某个类 Runnable 接口的方式可以适配 concurrent 包中的高级线程管理 API 线程的基本状态 线程有如下状态: NEW : 线程已经创建, 但还没有调用 start() 开始执行. RUNNABLE : 线程已经在 JVM 中开始运行, 但有 可能 在等待系统资源运行. BLOCKED : 线程在等待一个 monitor lock 以进入一个 synchronized 块. 也有可能是这个线程刚执行完 wait() , 其他线程又在获取 wait() 对象的 monitor lock . WAITING : 线程进入等待状态, 以下方法会使得线程进入 wait() 状态: Object.wait() join() LockSupport

1. 关键字volatile和synchronized对比？ 1）volatile是线程同步的轻量级实现，而synchronized是重量级操作。volatile只能修饰变量,而synchronized可以修饰方法，以及代码块。 2）volatile仅能保证数据可见性，不能保证原子性,而synchronized既可以保证数据的可见性，也能保证原子性。 3）volatile不会造成线程的阻塞,而synchronized可能会造成线程的阻塞。 4）volatile解决的是变量在多个线程之间的可见性,而synchronized解决的是多个线程之间访问资源的同步性。 2. Lock和synchronized对比？ 1）lock是一个锁，而synchronized是一个关键字。 2）lock不会主动释放锁，需要在finally块中添加unlock（）去释放锁。而synchronized会主动释放锁。 3）lock可以获取锁的信息，例如是否成功获取锁，而synchronized不能。 4）lock可以让等待的线程响应中断，而synchronized不能。 5）lock可以提高多个线程读操作的效率，而synchronized不能。 3. sleep方法和wait方法的比较 相同点： 二者都可以让线程处于冻结状态。 不同点： 1）sleep方法是Thread类中定义的方法

package seday10; /** * @author xingsir * 互斥锁 * 当使用synchronized锁定多个代码片段，并且他们指定的同步监视器对象是同一个时，那么这些代码片段之间就是互斥的， * 多个线程不能同时在这些代码片段中运行。 */ public class syncDemo4 { public static void main(String[] args) { Boo boo = new Boo();//实例化 Thread t1 = new Thread() {//线程一 public void run() { boo.mA();//调用方法 } }; Thread t2 = new Thread() {//线程二 public void run() { boo.mB();//调用方法 } }; t1.start();//启动 t2.start();//启动 } } class Boo{ public synchronized void mA() {//synchronized锁定多个代码片段 try { Thread thread =Thread.currentThread();//主线程 System.out.println(thread.getName()+":mA方法正在执行...");//打印 Thread.sleep(5000);/