当两条线程同时访问一个类的时候,可能会带来一些问题。并发线程重入可能会带来内存泄漏、程序不可控等等。不管是线程间的通讯还是线程共享数据都需要使用Java的锁机制控制并发代码产生的问题。本篇总结主要著名Java的锁机制,阐述多线程下如何使用锁机制进行并发线程沟通。

1、并发下的程序异常

  先看下下面两个代码,查看异常内容。

  异常1:单例模式

 package com.scl.thread;

 public class SingletonException
{
public static void main(String[] args)
{
// 开启十条线程进行分别测试输出类的hashCode,测试是否申请到同一个类
for (int i = 0; i < 10; i++)
{
new Thread(new Runnable()
{
@Override
public void run()
{
try
{
Thread.sleep(100);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + MySingle.getInstance().hashCode());
}
}).start();
}
}
} class MySingle
{
private static MySingle mySingle = null; private MySingle()
{
} public static MySingle getInstance()
{
if (mySingle == null) { mySingle = new MySingle(); }
return mySingle;
}
}

view code

运行结果如下:

  由上述可见,Thread-7与其他结果不一致,证明了在多线程并发的情况下这种单例写法存在问题,问题就在第40行。多个线程同时进入了空值判断,线程创建了新的类。

  异常2:线程重入,引发程序错误

现在想模拟国企生产规则,每个月生产100件产品,然后当月消费20件,依次更替。模拟该工厂全年的生产与销售

备注:举这个实例是为后面的信号量和生产者消费者问题做铺垫。可以另外举例,如开辟十条线程,每条线程内的任务就是进行1-10的累加,每条线程输出的结果不一定是55(线程重入导致)

 package com.scl.thread;

 //每次生产100件产品,每次消费20件产品,生产消费更替12轮
public class ThreadCommunicateCopy
{
public static void main(String[] args)
{
final FactoryCopy factory = new FactoryCopy();
new Thread(new Runnable()
{ @Override
public void run()
{
try
{
Thread.sleep(2000);
}
catch (InterruptedException e)
{
e.printStackTrace();
} for (int i = 1; i <= 12; i++)
{
factory.createProduct(i);
} }
}).start(); new Thread(new Runnable()
{ @Override
public void run()
{
try
{
Thread.sleep(2000);
}
catch (InterruptedException e)
{
e.printStackTrace();
} for (int i = 1; i <= 12; i++)
{
factory.sellProduct(i);
} }
}).start(); }
} class FactoryCopy
{
//生产产品
public void createProduct(int i)
{ for (int j = 1; j <= 100; j++)
{
System.out.println("第" + i + "轮生产,产出" + j + "件");
}
}
//销售产品
public void sellProduct(int i)
{
for (int j = 1; j <= 20; j++)
{
System.out.println("第" + i + "轮销售,销售" + j + "件");
} }
}

结果如下:

该结果不能把销售线程和生产线程的代码分隔开,如果需要分隔开。可以使用Java的锁机制。下面总结下如何处理以上两个问题。

2、使用多线程编程目的及一些Java多线程的基本知识

  使用多线程无非是期望程序能够更快地完成任务,这样并发编程就必须完成两件事情:线程同步及线程通信。

线程同步指的是:控制不同线程发生的先后顺序。

线程通信指的是:不同线程之间如何共享数据。

   Java线程的内存模型:每个线程拥有自己的栈,堆内存共享 [来源:Java并发编程艺术 ],如下图所示。 锁是线程间内存和信息沟通的载体,了解线程间通信会对线程锁有个比较深入的了解。后面也会详细总结Java是如何根据锁的信息进行两条线程之间的通信。

2、使用Java的锁机制

Java语音设计和数据库一样,同样存在着代码锁.实现Java代码锁比较简单,一般使用两个关键字对代码进行线程锁定。最常用的就是volatile和synchronized两个

2.1 synchronized

synchronized关键字修饰的代码相当于数据库上的互斥锁。确保多个线程在同一时刻只能由一个线程处于方法或同步块中,确保线程对变量访问的可见和排它,获得锁的对象在代码结束后,会对锁进行释放。

synchronzied使用方法有两个:①加在方法上面锁定方法,②定义synchronized块。

模拟生产销售循环,可以通过synchronized关键字控制线程同步。代码如下:

 package com.scl.thread;

 //每次生产100件产品,每次消费20件产品,生产消费更替10轮
public class ThreadCommunicate
{
public static void main(String[] args)
{
final FactoryCopy factory = new FactoryCopy();
new Thread(new Runnable()
{ @Override
public void run()
{
try
{
Thread.sleep(2000);
}
catch (InterruptedException e)
{
e.printStackTrace();
} for (int i = 1; i <= 12; i++)
{
factory.createProduct(i);
} }
}).start(); new Thread(new Runnable()
{ @Override
public void run()
{
try
{
Thread.sleep(2000);
}
catch (InterruptedException e)
{
e.printStackTrace();
} for (int i = 1; i <= 12; i++)
{
factory.sellProduct(i);
} }
}).start(); }
} class Factory
{
private boolean isCreate = true; public synchronized void createProduct(int i)
{
while (!isCreate)
{
try
{
this.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
} for (int j = 1; j <= 100; j++)
{
System.out.println("第" + i + "轮生产,产出" + j + "件");
}
isCreate = false;
this.notify();
} public synchronized void sellProduct(int i)
{
while (isCreate)
{
try
{
this.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
for (int j = 1; j <= 20; j++)
{
System.out.println("第" + i + "轮销售,销售" + j + "件");
}
isCreate = true;
this.notify();
}
}

  上述代码通过synchronized关键字控制生产及销售方法每次只能1条线程进入。代码中使用了isCreate标志位控制生产及销售的顺序。

注意:即使代码不使用isCreate标志位进行控制,代码只会出现 :thread-0 生产---thread-0 生产--- thread-0 生产(生产完毕) ---thread-1 销售...这种情况,不会出现生产跟销售交替。原因:使用Synchronized关键字对方法进行约束,默认锁定的是对一个的object类,直到代码结束,才会把锁给释放。因此使用该关键字进行限制时不会出现线程交叠现象。

备注:默认的使用synchronized修饰方法, 关键字会以当前实例对象作为锁对象,对线程进行锁定。

单例模式的修改可以在getInstance方式中添加synchronized关键字进行约束,即可。

wait方法和notify方法将在第三篇线程总结中讲解。

2.2 volatile

  volatile关键字主要用来修饰变量,关键字不像synchronized一样,能够块状地对代码进行锁定。该关键字可以看做对修饰的变量进行了读或写的同步操作。

  如以下代码:

 package com.scl.thread;

 public class NumberRange
{
private volatile int unSafeNum; public int getUnSafeNum()
{
return unSafeNum;
} public void setUnSafeNum(int unSafeNum)
{
this.unSafeNum = unSafeNum;
} public int addVersion()
{
return this.unSafeNum++;
}
}

代码编译后功能如下:

 package com.scl.thread;

 public class NumberRange
{
private volatile int unSafeNum; public synchronized int getUnSafeNum()
{
return unSafeNum;
} public synchronized void setUnSafeNum(int unSafeNum)
{
this.unSafeNum = unSafeNum;
} public int addVersion()
{
int temp = getUnSafeNum();
temp = temp + 1;
setUnSafeNum(temp);
return temp;
} }

由此可见,使用volatile变量进行自增或自减操作的时候,变量进行temp= temp+1这一步时,多条线程同时可能同时操作这一句代码,导致内容出差。线程代码内的原子性被破坏了。

单纯使用volatile来控制boolean或者某一个int类型的时候,感觉不出太大的作用。但当volatile在修饰一个对象的时候,对象必须按照步骤进行。在单线程的情况下new一个对象必须进行三步操作:①开辟存储空间 ②初始化 ③使用变量指向该内存。在并发的情况下,虚拟机创建对象可能依据这三步依次执行。可能③在②之前执行,那么就可能会导致程序抛出空指针异常。这时候可以使用volatile保证对象初始化原子性。

以上是对Java锁机制的总结,如有问题,烦请指出纠正。代码及例子很大一部分参考了《Java 并发编程艺术》[方腾飞 著]

Java多线程(二) 多线程的锁机制的更多相关文章

  1. Java多线程5:Synchronized锁机制

    一.前言 在多线程中,有时会出现多个线程对同一个对象的变量进行并发访问的情形,如果不做正确的同步处理,那么产生的后果就是“脏读”,也就是获取到的数据其实是被修改过的. 二.引入Synchronized ...

  2. Java并发编程:Concurrent锁机制解析

    Java并发编程:Concurrent锁机制解析 */--> code {color: #FF0000} pre.src {background-color: #002b36; color: # ...

  3. java 多线程总结篇4——锁机制

    在开发Java多线程应用程序中,各个线程之间由于要共享资源,必须用到锁机制.Java提供了多种多线程锁机制的实现方式,常见的有synchronized.ReentrantLock.Semaphore. ...

  4. java多线程技术之八(锁机制)

    Lock是java.util.concurrent.locks包下的接口,Lock 实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作,它能以更优雅的方式处理线程同步问题,我 ...

  5. Java多线程4:synchronized锁机制

    脏读 一个常见的概念.在多线程中,难免会出现在多个线程中对同一个对象的实例变量进行并发访问的情况,如果不做正确的同步处理,那么产生的后果就是"脏读",也就是取到的数据其实是被更改过 ...

  6. java 多线程10:synchronized锁机制 之 锁定类静态方法 和锁定类.Class 和 数据String的常量池特性

    同步静态方法 synchronized还可以应用在静态方法上,如果这么写,则代表的是对当前.java文件对应的Class类加锁.看一下例子,注意一下printC()并不是一个静态方法: public ...

  7. Java 并发和多线程(二) 多线程的优点 [转]

    原文:http://tutorials.jenkov.com/java-concurrency/benefits.html 作者:Jakob Jenkov        翻译:古圣昌         ...

  8. Java多线程学习——synchronized锁机制

    Java在多线程中使用同步锁机制时,一定要注意锁对对象,下面的例子就是没锁对对象(每个线程使用一个被锁住的对象时,得先看该对象的被锁住部分是否有人在使用) 例子:两个人操作同一个银行账户,丈夫在ATM ...

  9. 【转载】Java中的锁机制 synchronized & 偏向锁 & 轻量级锁 & 重量级锁 & 各自优缺点及场景 & AtomicReference

    参考文章: http://blog.csdn.net/chen77716/article/details/6618779 目前在Java中存在两种锁机制:synchronized和Lock,Lock接 ...

随机推荐

  1. show processlist 命令详解

      如果有 SUPER 权限,则可以看到全部的线程,否则,只能看到自己发起的线程(这是指,当前对应的 MySQL 帐户运行的线程). mysql> show processlist; +—–+— ...

  2. SQLite数据库中获取新插入数据的自增长ID

    SQLite数据库中有一有列名为ID的自增列,项目需求要在向数据库在插入新数据的同时返回新插入数据行的ID. 我这里用事务,把插入和查询语句通过ExecuteReader一起提交,返回DbDataRe ...

  3. 1、netlink 连接器 通信机制

    使用netlink之前,先参考一下资料:http://www.ibm.com/developerworks/cn/linux/l-connector/ netlink通信机制介绍:资料来源 linux ...

  4. c盘太小

    C:\Users\Administrator\AppData\Roaming\Apple Computer

  5. 关于struts2的modelDriven

    今天做毕业设计,前台往后台赋值,习惯性的用了modelDriven.但是刚写完就奇怪它的机理是怎样的,它怎么知道我前台传的参是哪个Model的属性(之前用servlet都是手动),于是手贱的ctrl点 ...

  6. App Thinning

    App Thinning 由于项目中需要开启Bitcode编译,之前对Bitcode也有些误区,故整理了下相关知识,仅供参考,如有不对,还请指出. 当前 iOS App 的编译打包方式是把适配兼容多个 ...

  7. Android 自学之列表视图ListView和ListActivity

    ListView是手机系统中使用非常广泛的一种组件,它以垂直列表的形式显示所有列表项. 创建ListView有两种方式: 直接使用ListView创建. 让Activity继承ListActivity ...

  8. 在IIS7.5上添加.NET4.0程序的虚拟目录时提示ASP.NET 4.0尚未在 Web 服务器上注册

    使用VS2010创建web应用程序时出现如下提示: ASP.NET 4.0尚未在 Web 服务器上注册. 解决方法: 首先IIS应用程序池添加 net framework4.0版本. 接着找到C:\W ...

  9. Flexible 弹性盒子模型之CSS flex-direction

    实例 设置 <div> 元素内弹性盒元素的方向为相反的顺序: div { display:flex; flex-direction:row-reverse; } 复制 效果预览 浏览器支持 ...

  10. ContentProvider(一)

    注册ContentProvider: <provider android:name=".provider.UserProvider" android:authorities= ...