java多线程同步代码块 java多线程怎么保持数据的同步性
初学Java多线程：使用Synchronized块同步方法
synchronized关键字有两种用法 第一种就是在《使用Synchronized关键字同步类方法》一文中所介绍的直接用在方法的定义中 另外一种就是synchronized块 我们不仅可以通过synchronized块来同步一个对象变量巧顷 也可以使用synchronized块来同步类中的静态孝宽陆方法和非静态方法
创新互联建站长期为1000+客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为岚县企业提供专业的成都做网站、成都网站制作，岚县网站改版等技术服务。拥有10年丰富建站经验和众多成功案例,为您定制开发。
synchronized块的语法如下
public void method()
{
… …
synchronized(表达式)
{
… …
}
}
一 非静态类方法的同步
从《使用Synchronized关键字同步类方法》一文中我们知道使用synchronized关键字来定义方法就会锁定类中所有使用synchronzied关键字定义的静态方法或非静态方法 但这并不好理解 而如果使用synchronized块来达到同样的效果 就不难理解为什么会产生这种效果了 如果想使用synchronized块来锁定类中所有的同步非静态方法 需要使用this做为synchronized块的参数传入synchronized块国 代码如下
通过synchronized块同步非静态方法
public class SyncBlock
{
public void method ()
{
synchronized(this) // 相当于对method 方法使用synchronized关键字
{
… …
}
}
public void method ()
{
synchronized(this) // 相当于对method 方法使用synchronized关键字
{
… …
}
}
public synchronized void method ()
{
… …
}
}
在上面的代码中的method 和method 方法中使用了synchronized块 而第 行的method 方法仍然使用synchronized关键字来定义方法 在使用同一个SyncBlock类实例时 这三个方法只要有一个正在执行 其他两个方法就会因未获得同步锁而被阻塞 在使用synchronized块时要想达到和synchronized关键字同样的效果 必须将所有的代码都写在synchronized块中 否则 将无法使当前方法中的所有代码和其他的方法同步
除了使用this做为synchronized块的参数外 还可以使用SyncBlock this作为synchronized块的参数来达到同样的效果
在内类（InnerClass）的方法中使用synchronized块来时 this只表示内类 和外类(OuterClass)没有关系 但内类的非静态方法可以和外类的非静态方法同步 如在内类InnerClass中加一个method 方法 并使method 方法和SyncBlock的三个方法同步 代码如下
使内类的非静态方法和外类的非静态方法同步
public class SyncBlock
{
… …
class InnerClass
{
public void method ()
{
synchronized(SyncBlock this)
{
… …
}
}
}
… …
}
在上面SyncBlock类的新版本中 InnerClass类的method 方法和SyncBlock类的其他三个方法同步 因此 method method method 和method 四个方法在同一时间巧手只能有一个方法执行
Synchronized块不管是正常执行完 还是因为程序出错而异常退出synchronized块 当前的synchronized块所持有的同步锁都会自动释放 因此 在使用synchronized块时不必担心同步锁的释放问题
二 静态类方法的同步
由于在调用静态方法时 对象实例不一定被创建 因此 就不能使用this来同步静态方法 而必须使用Class对象来同步静态方法 代码如下
通过synchronized块同步静态方法
public class StaticSyncBlock
{
public static void method ()
{
synchronized(StaticSyncBlock class)
{
… …
}
}
public static synchronized void method ()
{
… …
}
}
在同步静态方法时可以使用类的静态字段class来得到Class对象 在上例中method 和method 方法同时只能有一个方法执行 除了使用class字段得到Class对象外 还可以使用实例的getClass方法来得到Class对象 上例中的代码可以修改如下
使用getClass方法得到Class对象
public class StaticSyncBlock
{
public static StaticSyncBlock instance;
public StaticSyncBlock()
{
instance = this;
}
public static void method ()
{
synchronized(instance getClass())
{
}
}
}
在上面代码中通过一个public的静态instance得到一个StaticSyncBlock类的实例 并通过这个实例的getClass方法得到了Class对象（一个类的所有实例通过getClass方法得到的都是同一个Class对象 因此 调用任何一个实例的getClass方法都可以） 我们还可以通过Class对象使不同类的静态方法同步 如Test类的静态方法method和StaticSyncBlock类的两个静态方法同步 代码如下
Test类的method方法和StaticSyncBlock类的method method 方法同步
public class Test
{
public static void method()
{
synchronized(StaticSyncBlock class)
{
}
}
}
lishixinzhi/Article/program/Java/gj/201311/27374
Java多线程我用了同步代码块之后，为什么一直都是主线程在执行，别的线程根本没执行?
你的synchronized将陆团while循环都锁住了，所以其中一个线程会将整个while循环执行玩再走其他线程，但你的共享数早缺橘据扮晌这时候已经被循环至0了，所以只有一个线程在执行
java多线程有几种实现方法？线程之间如何同步
一、乱漏为什么要线程同步
因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。举个例子，如果一个银行账户同时被两个线程操作，一个取100块，一激谈个存钱100块。假设账户原本有0块，如果取钱线程和存钱线程同时发生，会出现什么结果呢？取钱不成功，账户余额是100.取钱成功了，账户余额是0.那到底是哪个呢？很难说清楚。因此多线程同步就是要解决这个问题。
二、不同步时的代码
Bank.Java
package threadTest;
/**
* @author ww
*
*/
public class Bank {
private int count =0;//账户余额
//存钱
public void addMoney(int money){
count +=money;
System.out.println(System.currentTimeMillis()+"存进："+money);
}
//取钱
public void subMoney(int money){
if(count-money 0){
System.out.println("余额不足");
return;
}
count -=money;
System.out.println(+System.currentTimeMillis()+"取出："+money);
}
//查询
public void lookMoney(){
System.out.println("账户余额："+count);
}
}
SyncThreadTest.java
package threadTest;
public class SyncThreadTest {
public static void main(String args[]){
final Bank bank=new Bank();
Thread tadd=new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
bank.addMoney(100);
bank.lookMoney();
System.out.println("\n");
}
}
});
Thread tsub = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
bank.subMoney(100);
bank.lookMoney();
System.out.println("\n");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
});
tsub.start();
tadd.start();
}
}
余额不足
账户余额：0
余额不足
账户余额：100
1441790503354存进：100
账户余额：100
1441790504354存进：100
账户余额：100
1441790504354取出：100
账户余额：100
1441790505355存进：100
账户余额：100
1441790505355取出：100
账户余额：100
三、使用同步时的代码
（1）同步方法：
即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护明陪碰整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。
修改后的Bank.java
package threadTest;
/**
* @author ww
*
*/
public class Bank {
private int count =0;//账户余额
//存钱
public synchronized void addMoney(int money){
count +=money;
System.out.println(System.currentTimeMillis()+"存进："+money);
}
//取钱
public synchronized void subMoney(int money){
if(count-money 0){
System.out.println("余额不足");
return;
}
count -=money;
System.out.println(+System.currentTimeMillis()+"取出："+money);
}
//查询
public void lookMoney(){
System.out.println("账户余额："+count);
}
}
再看看运行结果：
余额不足
账户余额：0
余额不足
账户余额：0
1441790837380存进：100
账户余额：100
1441790838380取出：100
账户余额：0
1441790838380存进：100
账户余额：100
1441790839381取出：100
账户余额：0
瞬间感觉可以理解了吧。
注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类
（2）同步代码块
即有synchronized关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁，从而实现同步
Bank.java代码如下：
package threadTest;
/**
* @author ww
*
*/
public class Bank {
private int count =0;//账户余额
//存钱
public void addMoney(int money){
synchronized (this) {
count +=money;
}
System.out.println(System.currentTimeMillis()+"存进："+money);
}
//取钱
public void subMoney(int money){
synchronized (this) {
if(count-money 0){
System.out.println("余额不足");
return;
}
count -=money;
}
System.out.println(+System.currentTimeMillis()+"取出："+money);
}
//查询
public void lookMoney(){
System.out.println("账户余额："+count);
}
}
运行结果如下：
余额不足
账户余额：0
1441791806699存进：100
账户余额：100
1441791806700取出：100
账户余额：0
1441791807699存进：100
账户余额：100
效果和方法一差不多。
注：同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。
（3）使用特殊域变量(volatile)实现线程同步
a.volatile关键字为域变量的访问提供了一种免锁机制
b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新
c.因此每次使用该域就要重新计算，而不是使用寄存器中的值
d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量
Bank.java代码如下：
package threadTest;
/**
* @author ww
*
*/
public class Bank {
private volatile int count = 0;// 账户余额
// 存钱
public void addMoney(int money) {
count += money;
System.out.println(System.currentTimeMillis() + "存进：" + money);
}
// 取钱
public void subMoney(int money) {
if (count - money 0) {
System.out.println("余额不足");
return;
}
count -= money;
System.out.println(+System.currentTimeMillis() + "取出：" + money);
}
// 查询
public void lookMoney() {
System.out.println("账户余额：" + count);
}
}
运行效果怎样呢？
余额不足
账户余额：0
余额不足
账户余额：100
1441792010959存进：100
账户余额：100
1441792011960取出：100
账户余额：0
1441792011961存进：100
账户余额：100
是不是又看不懂了，又乱了。这是为什么呢？就是因为volatile不能保证原子操作导致的，因此volatile不能代替synchronized。此外volatile会组织编译器对代码优化，因此能不使用它就不适用它吧。它的原理是每次要线程要访问volatile修饰的变量时都是从内存中读取，而不是存缓存当中读取，因此每个线程访问到的变量值都是一样的。这样就保证了同步。
（4）使用重入锁实现线程同步
在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。ReentrantLock类是可重入、互斥、实现了Lock接口的锁， 它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。
ReenreantLock类的常用方法有：
ReentrantLock() : 创建一个ReentrantLock实例
lock() : 获得锁
unlock() : 释放锁
注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用
Bank.java代码修改如下：
package threadTest;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author ww
*
*/
public class Bank {
private int count = 0;// 账户余额
//需要声明这个锁
private Lock lock = new ReentrantLock();
// 存钱
public void addMoney(int money) {
lock.lock();//上锁
try{
count += money;
System.out.println(System.currentTimeMillis() + "存进：" + money);
}finally{
lock.unlock();//解锁
}
}
// 取钱
public void subMoney(int money) {
lock.lock();
try{
if (count - money 0) {
System.out.println("余额不足");
return;
}
count -= money;
System.out.println(+System.currentTimeMillis() + "取出：" + money);
}finally{
lock.unlock();
}
}
// 查询
public void lookMoney() {
System.out.println("账户余额：" + count);
}
}
运行效果怎么样呢？
余额不足
账户余额：0
余额不足
账户余额：0
1441792891934存进：100
账户余额：100
1441792892935存进：100
账户余额：200
1441792892954取出：100
账户余额：100
效果和前两种方法差不多。
如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码 。如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁
（5）使用局部变量实现线程同步
Bank.java代码如下：
package threadTest;
/**
* @author ww
*
*/
public class Bank {
private static ThreadLocalInteger count = new ThreadLocalInteger(){
@Override
protected Integer initialValue() {
// TODO Auto-generated method stub
return 0;
}
};
// 存钱
public void addMoney(int money) {
count.set(count.get()+money);
System.out.println(System.currentTimeMillis() + "存进：" + money);
}
// 取钱
public void subMoney(int money) {
if (count.get() - money 0) {
System.out.println("余额不足");
return;
}
count.set(count.get()- money);
System.out.println(+System.currentTimeMillis() + "取出：" + money);
}
// 查询
public void lookMoney() {
System.out.println("账户余额：" + count.get());
}
}
运行效果：
余额不足
账户余额：0
余额不足
账户余额：0
1441794247939存进：100
账户余额：100
余额不足
1441794248940存进：100
账户余额：0
账户余额：200
余额不足
账户余额：0
1441794249941存进：100
账户余额：300
看了运行效果，一开始一头雾水，怎么只让存，不让取啊？看看ThreadLocal的原理：
如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。现在明白了吧，原来每个线程运行的都是一个副本，也就是说存钱和取钱是两个账户，知识名字相同而已。所以就会发生上面的效果。
ThreadLocal与同步机制
a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题
b.前者采用以"空间换时间"的方法，后者采用以"时间换空间"的方式
网页题目：java多线程同步代码块 java多线程怎么保持数据的同步性
分享链接：http://ybzwz.com/article/ddpgchj.html
