本文详细介绍了Java中多线程同步的各种机制，包括synchronized关键字、ThreadLocal、volatile关键字、ReentrantLock、阻塞队列及AtomicInteger等的使用方法与原理，通过实例帮助理解。
1）多线程并发时，多个线程同时请求同一个资源，必然导致此资源的数据不安全，A线程修改了B线
程的处理的数据，而B线程又修改了A线程处理的数理。显然这是由于全局资源造成的，有时为了解
决此问题，优先考虑使用局部变量，退而求其次使用同步代码块，出于这样的安全考虑就必须牺牲
系统处理性能，加在多线程并发时资源挣夺最激烈的地方，这就实现了线程的同步机制
同步：A线程要请求某个资源，但是此资源正在被B线程使用中，因为同步机制存在，A线程请求
不到，怎么办，A线程只能等待下去
异步：A线程要请求某个资源，但是此资源正在被B线程使用中，因为没有同步机制存在，A线程
仍然请求的到，A线程无需等待
java中实现多线程
1）继承Thread,重写里面的run方法
2）实现runnable接口
比较推荐后者，第一，java没有单继承的限制第二，还可以隔离代码
2）线程池
要知道在计算机中任何资源的创建，包括线程，都需要消耗系统资源的。在WEB服务中，对于web服
务器的响应速度必须要尽可能的快，这就容不得每次在用户提交请求按钮后，再创建线程提供服务
。为了减少用户的等待时间，线程必须预先创建，放在线程池中，线程池可以用HashTable这种数
据结构来实现，看了Apach HTTP服务器的线程池的源代码，用是就是HashTable,KEY用线程对象，
value 用ControlRunnable，ControlRunnable是线程池中唯一能干活的线程，是它指派线程池中的
线程对外提供服务。出于安全考虑，Apach HTTP服务器的线程池它是同步的。
3）Java同步机制有4种实现方式：
1.synchronized
同步方法
即有synchronized关键字修饰的方法。
由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，
内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。
代码如：
public synchronized void save(){}
同步代码块
即有synchronized关键字修饰的语句块。
被该关键字修饰的语句块会自动被加上内置锁，从而实现同步
代码如：
synchronized(object){
}
注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类
2.ThreadLocal
ThreadLocal 保证不同线程拥有不同实例，相同线程一定拥有相同的实例，即为每一个使用该
变量的线程提供一个该变量值的副本，每一个线程都可以独立改变自己的副本，而不是与其它线程
的副本冲突。
优势：提供了线程安全的共享对象
与其它同步机制的区别：同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之
间进行通信；而 ThreadLocal 是隔离多个线程的数据共享，从根本上就不在多个线程之间共享资源
，这样当然不需要多个线程进行同步了。
3.volatile
volatile 修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。
而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。
优势：这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
缘由：Java 语言规范中指出，为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而
且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。这样当多个线程同时与某
个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。而 volatile 关键字就
是提示 VM ：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。
使用技巧：在两个或者更多的线程访问的成员变量上使用 volatile 。当要访问的变量已在
synchronized 代码块中，或者为常量时，不必使用。
线程为了提高效率，将某成员变量(如A)拷贝了一份（如B），线程中对A的访问其实访问的
是B。只在某些动作时才进行A和B的同步，因此存在A和B不一致的情况。volatile就是用来避免这种
情况的。 volatile告诉jvm，它所修饰的变量不保留拷贝，直接访问主内存中的（读操作多时使用
较好；线程间需要通信，本条做不到）
Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自
动发现 volatile 变量的最新值。Volatile 变量可用于提供线程安全，但是只能应用于非常有限的
一组用例：多个变量之间或者某个变量的当前值与修改后值之间没有约束。
您只能在有限的一些情形下使用 volatile 变量替代锁。要使 volatile 变量提供理
想的线程安全，必须同时满足下面两个条件：
对变量的写操作不依赖于当前值；该变量没有包含在具有其他变量的不变式中。
//只给出要修改的代码，其余代码与上同
class Bank {
//需要同步的变量加上volatile
private volatile int account = 100;
public int getAccount() {
return account;
}
//这里不再需要synchronized
public void save(int money) {
account += money;
}
｝4.使用重入锁实现线程同步 ReenreantLock
ReentrantLock感觉上是synchronized的增强版，synchronized的特点是使用简单，一切交给JVM去处理，但是功能上是比较薄弱的。在JDK1.5之前，ReentrantLock的性能要好于synchronized，由于对JVM进行了优化，现在的JDK版本中，两者性能是不相上下的。如果是简单的实现，不要刻意去使用ReentrantLock。
相比于synchronized，ReentrantLock在功能上更加丰富，它具有可重入、可中断、可限时、公平锁等特点。
ReenreantLock类的常用方法有：
ReentrantLock() : 创建一个ReentrantLock实例
lock() : 获得锁
unlock() : 释放锁
package test;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Bank {
private int account = 100;
//需要声明这个锁
private Lock lock = new ReentrantLock();
public int getAccount() {
return account;
}
//这里不再需要synchronized
public void save(int money) {
lock.lock();
try{
account += money;
}finally{
lock.unlock();
}
}
}
lockInterruptibly()：获得响应中断的锁
interrupt()：中断
可中断：在java中,线程的中断(interrupt)只是改变了线程的中断状态。对于执行一般逻辑的线程,如果调用它的interrupt()方法，那么对这个线程没有任何影响，线程会继续正常地执行下去；对于wait中等待notify/notifyAll唤醒的线程（包括sleep，join），其实这个线程已经"暂停"执行，因为它正在某一对象的休息室中，这时如果它的中断状态被改变，那么它就会抛出异常。那么它与被notify/All唤醒的线程的区别是，正常唤醒的线程会继续执行wait下面的语句，而在wait中被中断的线程则将控制权交给了catch语句，一些正常的逻辑要被放到catch中来运行。
因为普通的lock.lock()是不能响应中断的，lock.lockInterruptibly()能够响应中断。所以利用这一点来处理线程的死锁问题。案例代码如下：
package test;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.concurrent.locks.ReentrantLock;
public class Test implements Runnable
{
public static ReentrantLock lock1 = new ReentrantLock();
public static ReentrantLock lock2 = new ReentrantLock();
int lock;
public Test(int lock)
{
this.lock = lock;
}
@Override
public void run()
{
try
{
if (lock == 1)
{
lock1.lockInterruptibly();
try
{
Thread.sleep(500);
}
catch (Exception e)
{
e.printStackTrace();
}
lock2.lockInterruptibly();
}
else
{
lock2.lockInterruptibly();
try
{
Thread.sleep(500);
}
catch (Exception e)
{
e.printStackTrace();
}
lock1.lockInterruptibly();
}
}
catch (Exception e)
{
// TODO: handle exception
e.printStackTrace();
}
finally
{
//isHeldByCurrentThread()查询当前线程是否保持此锁
if (lock1.isHeldByCurrentThread())
{
lock1.unlock();
}
if (lock2.isHeldByCurrentThread())
{
lock2.unlock();
}
System.out.println(Thread.currentThread().getId() + ":线程退出");
}
}
public static void main(String[] args) throws InterruptedException
{
Test t1 = new Test(1);
Test t2 = new Test(2);
Thread thread1 = new Thread(t1);
Thread thread2 = new Thread(t2);
thread1.start();
thread2.start();
Thread.sleep(1000);
DeadlockChecker.check();
}
static class DeadlockChecker
{
//ThreadMXBean是Java 虚拟机线程系统的管理接口。实现此接口的实例是一个 MXBean，可以通过调用 ManagementFactory.getThreadMXBean() 方法或从平台 MBeanServer 方法获得它。
private final static ThreadMXBean mbean = ManagementFactory.getThreadMXBean();
final static Runnable deadlockChecker = new Runnable()
{
@Override
public void run()
{
while (true)
{
//线程 ID 是一个通过调用线程的 Thread.getId() 方法返回的 long 型正值。线程 ID 在其生存期间是唯一的。线程终止时，该线程 ID 可以被重新使用。
//findDeadlockedThreads()线程的死锁检测方法，返回装有死锁线程ID的long型数组
long[] deadlockedThreadIds = mbean.findDeadlockedThreads();
if (deadlockedThreadIds != null)
{
//getThreadInfo(long[], boolean, boolean)用来获取线程堆栈的跟踪(各种状态信息的复制)，这里的目的是为了获取所有处于活动状态线程的线程信息
ThreadInfo[] threadInfos = mbean.getThreadInfo(deadlockedThreadIds);
//两层循环为了确保被中断的线程是处于活动状态中的线程
for (Thread t : Thread.getAllStackTraces().keySet())
{
for (int i = 0; i < threadInfos.length; i++)
{
if(t.getId() == threadInfos[i].getThreadId())
{
t.interrupt();
}
}
}
}
try
{
Thread.sleep(5000);
}
catch (Exception e)
{
// TODO: handle exception
}
}
}
};
public static void check()
{
Thread t = new Thread(deadlockChecker);
//设置为守护线程，作用：当守护线程是jvm中仅剩的线程时它会自动离开。垃圾回收GC就是一个典型的守护线程。
//注：当所有的常规线程运行完毕以后，守护线程不管运行到哪里，java虚拟机都会退出运行，所以守护线程中最好不要写一些会影响程序的业务。
t.setDaemon(true);
t.start();
}
}
}可限时：超时不能获得锁，就返回false，不会永久等待构成死锁
使用lock.tryLock(long timeout, TimeUnit unit)来实现可限时锁，参数为时间和单位。
举个例子来说明下可限时：
package test;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class Test implements Runnable
{
public static ReentrantLock lock = new ReentrantLock();
@Override
public void run()
{
try
{
if (lock.tryLock(5, TimeUnit.SECONDS))
{
Thread.sleep(6000);
}
else
{
System.out.println("get lock failed");
}
}
catch (Exception e)
{
}
finally
{
if (lock.isHeldByCurrentThread())
{
lock.unlock();
}
}
}
public static void main(String[] args)
{
Test t = new Test();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
t2.start();
}
}使用两个线程来争夺一把锁，当某个线程获得锁后，sleep6秒，每个线程都只尝试5秒去获得锁。
所以必定有一个线程无法获得锁。无法获得后就直接退出了。
输出：
get lock failed公平锁：
public ReentrantLock(boolean fair)
public static ReentrantLock fairLock = new ReentrantLock(true);一般意义上的锁是不公平的，不一定先来的线程能先得到锁，后来的线程就后得到锁。不公平的锁可能会产生饥饿现象。
公平锁的意思就是，这个锁能保证线程是先来的先得到锁。虽然公平锁不会产生饥饿现象，但是公平锁的性能会比非公平锁差很多。
5.使用阻塞队列实现线程同步
使用javaSE5.0版本中新增的java.util.concurrent包将有助于简化开发。
本小节主要是使用LinkedBlockingQueue<E>来实现线程的同步
LinkedBlockingQueue<E>是一个基于已连接节点的，范围任意的blocking queue。
队列是先进先出的顺序（FIFO）
LinkedBlockingQueue 类常用方法
LinkedBlockingQueue() : 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue
put(E e) : 在队尾添加一个元素，如果队列满则阻塞
size() : 返回队列中的元素个数
take() : 移除并返回队头元素，如果队列空则阻塞
package test;
import java.util.Random;
import java.util.concurrent.LinkedBlockingQueue;
/**
* 用阻塞队列实现线程同步 LinkedBlockingQueue的使用
* 当队列中没有元素时take会被阻塞
* 当队列慢了时put会被阻塞
*/
public class BlockingSynchronizedThread {
/**
* 定义一个阻塞队列用来存储生产出来的商品
*/
private LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>(10);
/**
* 定义生产商品个数
*/
private static final int size = 20;
/**
* 定义启动线程的标志，为0时，启动生产商品的线程；为1时，启动消费商品的线程
*/
private int flag = 0;
private class LinkBlockThread implements Runnable {
@Override
public void run() {
int new_flag = flag++;
System.out.println("启动线程 " + new_flag);
if (new_flag == 0) {
for (int i = 0; i < size; i++) {
int b = new Random().nextInt(255);
System.out.println("生产商品：" + b + "号");
try {
queue.put(b);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("仓库中还有商品：" + queue.size() + "个");
try {
Thread.sleep(100);//生产速度大于消费速度
//Thread.sleep(5000);消费速度大于生产速度
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} else {
for (int i = 0; i < size / 2; i++) {
try {
int n = queue.take();
System.out.println("消费者买去了" + n + "号商品");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("仓库中还有商品：" + queue.size() + "个");
try {
Thread.sleep(5000);
//Thread.sleep(100);
} catch (Exception e) {
// TODO: handle exception
}
}
}
}
}
public static void main(String[] args) {
BlockingSynchronizedThread bst = new BlockingSynchronizedThread();
LinkBlockThread lbt = bst.new LinkBlockThread();
Thread thread1 = new Thread(lbt);
Thread thread2 = new Thread(lbt);
thread1.start();
thread2.start();
}
}注：BlockingQueue<E>定义了阻塞队列的常用方法，尤其是三种添加元素的方法，我们要多加注意，当队列满时：
add()方法会抛出异常
offer()方法返回false
put()方法会阻塞
6.AtomicInteger
AtomicInteger，一个提供原子操作的Integer的类。在Java语言中，++i和i++操作并不是线程安全的，在使用的时候，不可避免的会用到synchronized关键字。而AtomicInteger则通过一种线程安全的加减操作接口。
AtomicInteger提供的接口。
//获取当前的值
public final int get()
//取当前的值，并设置新的值
public final int getAndSet(int newValue)
//获取当前的值，并自增
public final int getAndIncrement()
//获取当前的值，并自减
public final int getAndDecrement()
//获取当前的值，并加上预期的值
public final int getAndAdd(int delta)
synchronized的方法和一个AtomicInteger的方法来进行测试，直观的感受下性能上的差异
package test;
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntegerCompareTest {
private int value;
public AtomicIntegerCompareTest(int value){
this.value = value;
}
public synchronized int increase(){
return value++;
}
public static void main(String args[]){
long start = System.currentTimeMillis();
AtomicIntegerCompareTest test = new AtomicIntegerCompareTest(0);
for( int i=0;i< 1000000;i++){
test.increase();
}
long end = System.currentTimeMillis();
System.out.println("time elapse:"+(end -start));
long start1 = System.currentTimeMillis();
AtomicInteger atomic = new AtomicInteger(0);
for( int i=0;i< 1000000;i++){
atomic.incrementAndGet();
}
long end1 = System.currentTimeMillis();
System.out.println("time elapse:"+(end1 -start1) );
/*运行结果：time elapse:19
time elapse:9
AtomicInteger拥有更高效的性能
*/
}
}
4）一旦一个线程进入一个实例的任何同步方法，别的线程将不能
进入该同一实例的其它同步方法，但是该实例的非同步方法仍然能够被调用
Demo1：
package test;
public class SynTest {
//非同步
static void method(Thread thread){
System.out.println("begin "+thread.getName());
try{
Thread.sleep(2000);
}catch(Exception ex){
ex.printStackTrace();
}
System.out.println("end "+thread.getName());
}
//同步方式一：同步方法
synchronized static void method1(Thread thread){//这个方法是同步的方法，每次只有一个线程可以进来
System.out.println("begin "+thread.getName());
try{
Thread.sleep(2000);
}catch(Exception ex){
ex.printStackTrace();
}
System.out.println("end "+thread.getName());
}
//同步方式二：同步代码块
static void method2(Thread thread){
synchronized(SynTest.class) {
System.out.println("begin "+thread.getName());
try{
Thread.sleep(2000);
}catch(Exception ex){
ex.printStackTrace();
}
System.out.println("end "+thread.getName());
}
}
//同步方式三：使用同步对象锁
private static Object _lock1=new Object();
private static byte _lock2[]={};//据说，此锁更可提高性能。源于：锁的对象越小越好
static void method3(Thread thread){
synchronized(_lock1) {
System.out.println("begin "+thread.getName());
try{
Thread.sleep(2000);
}catch(Exception ex){
ex.printStackTrace();
}
System.out.println("end "+thread.getName());
}
}
public static void main(String[] args){
//启动3个线程，这里用了匿名类
for(int i=0;i<3;i++){
new Thread(){
public void run(){
//method(this);
method1(this);
method2(this);
method3(this);
}
}.start();
}
}
}
Demo2：
package test;
public class SynTest2 {
public static void main(String[] args){
Callme target=new Callme();
Caller ob1=new Caller(target,"Hello");
Caller ob2=new Caller(target,"Synchronized");
Caller ob3=new Caller(target,"World");
}
}
package test;
public class Callme {
synchronized void test(){
System.out.println("测试是否是：一旦一个线程进入一个实例的任何同步方法，别的线程将不能进入该同一实例的其它同步方法，但是该实例的非同步方法仍然能够被调用");
}
void nonsynCall(String msg){
System.out.println("["+msg);
System.out.println("]");
}
synchronized void synCall(String msg){
System.out.println("["+msg);
System.out.println("]");
}
}
class Caller implements Runnable{
String msg;
Callme target;
Thread t;
Caller(Callme target,String msg){
this.target=target;
this.msg=msg;
t=new Thread(this);
t.start();
}
public void run() {
// TODO Auto-generated method stub
//target.nonsynCall(msg);
target.synCall(msg);
target.test();
}
}
扫一扫
3392
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
