java中同步的方法

㈠ java类的实例化顺序是什么样的Java线程同步的方式有哪些

引言：java是在1990年初 ，被詹姆斯•高斯林等人开发的一门面向对象的编程语言。起初，java被称为0ak，来经过发展0ak改名为java，与1995年的五月份正式向大家发布。

一、java类的实例化顺序

java的实例化顺序在继承没有的情况

单独一个类的场景下，初始化顺序为依次为静态数据，继承的基类的构造函数，成员变量，被调用的构造函数。

其中静态数据只会初始化一次。（静态数据包括静态代码块和静态变量，每个类的静态数据只会初始化一次）

在继承的情况下

添加两个基类，让继承父亲，父亲继承祖父。

继承的情况就比较复杂了。由继承了基类，还将往上回溯，递归地调用基类的无参构造方法。

在我们的例子中，在初始化静态数据后，会先往上追溯，调用父的默认构造方法，此时再往上追溯到爷爷的默认构造方法。

无论是java还是什么别的东西他都体现了现代社会与信息技术的不断发展，人们在进行进行技术开发时也有了越来越多的方法。程序类的工作也有了更为快捷的方法，这为信息技术的发展也提供了更好的发展方法

㈡ JAVA中线程同步方法有哪些

JAVA中线程同步方法一般有以下三种：
1 wait方法：
该方法属于Object的方法，wait方法的作用是使得当前调用wait方法所在部分（代码块）的线程停止执行，并释放当前获得的调用wait所在的代码块的锁，并在其他线程调用notify或者notifyAll方法时恢复到竞争锁状态（一旦获得锁就恢复执行）。
调用wait方法需要注意几点：
第一点：wait被调用的时候必须在拥有锁（即synchronized修饰的）的代码块中。
第二点：恢复执行后，从wait的下一条语句开始执行，因而wait方法总是应当在while循环中调用，以免出现恢复执行后继续执行的条件不满足却继续执行的情况。
第三点：若wait方法参数中带时间，则除了notify和notifyAll被调用能激活处于wait状态（等待状态）的线程进入锁竞争外，在其他线程中interrupt它或者参数时间到了之后，该线程也将被激活到竞争状态。
第四点：wait方法被调用的线程必须获得之前执行到wait时释放掉的锁重新获得才能够恢复执行。
2 notify方法和notifyAll方法：
notify方法通知调用了wait方法，但是尚未激活的一个线程进入线程调度队列（即进入锁竞争），注意不是立即执行。并且具体是哪一个线程不能保证。另外一点就是被唤醒的这个线程一定是在等待wait所释放的锁。
notifyAll方法则唤醒所有调用了wait方法，尚未激活的进程进入竞争队列。
3 synchronized关键字：
第一点：synchronized用来标识一个普通方法时，表示一个线程要执行该方法，必须取得该方法所在的对象的锁。
第二点：synchronized用来标识一个静态方法时，表示一个线程要执行该方法，必须获得该方法所在的类的类锁。
第三点：synchronized修饰一个代码块。类似这样：synchronized(obj) { //code.... }。表示一个线程要执行该代码块，必须获得obj的锁。这样做的目的是减小锁的粒度，保证当不同块所需的锁不冲突时不用对整个对象加锁。利用零长度的byte数组对象做obj非常经济。

㈢ java中同步有几种方式啊

1。同步代码块：
synchronized(同一个数据){} 同一个数据：就是N条线程同时访问一个数据。
2。
同步方法：
public synchronized 数据返回类型 方法名(){}
就
是使用 synchronized 来修饰某个方法，则该方法称为同步方法。对于同步方法而言，无需显示指定同步监视器，同步方法的同步监视器是
this
也就是该对象的本身（这里指的对象本身有点含糊，其实就是调用该同步方法的对象）通过使用同步方法，可非常方便的将某类变成线程安全的类，具有如下特征：
1，该类的对象可以被多个线程安全的访问。
2，每个线程调用该对象的任意方法之后，都将得到正确的结果。
3，每个线程调用该对象的任意方法之后，该对象状态依然保持合理状态。
注：synchronized关键字可以修饰方法，也可以修饰代码块，但不能修饰构造器，属性等。
实现同步机制注意以下几点： 安全性高，性能低，在多线程用。性能高，安全性低，在单线程用。
1，不要对线程安全类的所有方法都进行同步，只对那些会改变共享资源方法的进行同步。
2，如果可变类有两种运行环境，当线程环境和多线程环境则应该为该可变类提供两种版本：线程安全版本和线程不安全版本(没有同步方法和同步块)。在单线程中环境中，使用线程不安全版本以保证性能，在多线程中使用线程安全版本.

线程通讯：
为什么要使用线程通讯？
当
使用synchronized
来修饰某个共享资源时(分同步代码块和同步方法两种情况）,当某个线程获得共享资源的锁后就可以执行相应的代码段，直到该线程运行完该代码段后才释放对该

共享资源的锁，让其他线程有机会执行对该共享资源的修改。当某个线程占有某个共享资源的锁时，如果另外一个线程也想获得这把锁运行就需要使用wait()
和notify()/notifyAll()方法来进行线程通讯了。
Java.lang.object 里的三个方法wait() notify() notifyAll()
wait方法导致当前线程等待，直到其他线程调用同步监视器的notify方法或notifyAll方法来唤醒该线程。
wait(mills)方法
都是等待指定时间后自动苏醒，调用wait方法的当前线程会释放该同步监视器的锁定，可以不用notify或notifyAll方法把它唤醒。
notify()
唤醒在同步监视器上等待的单个线程，如果所有线程都在同步监视器上等待，则会选择唤醒其中一个线程，选择是任意性的，只有当前线程放弃对该同步监视器的锁定后，也就是使用wait方法后，才可以执行被唤醒的线程。
notifyAll()方法
唤醒在同步监视器上等待的所有的线程。只用当前线程放弃对该同步监视器的锁定后，才可以执行被唤醒的线程

㈣ 初学Java多线程：使用Synchronized块同步方法

synchronized关键字有两种用法 第一种就是在《使用Synchronized关键字同步类方法》一文中所介绍的直接用在方法的定义中 另外一种就是synchronized块 我们不仅可以通过synchronized块来同步一个对象变量巧顷 也可以使用synchronized块来同步类中的静态孝宽陆方法和非静态方法

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)

{

}

}

}

㈤ java 方法同步

设置三个同步变量不就完了，然后synchronized的时候就同步这三个变量区分就行了

㈥ java中实现同步的两种方式syschronized和lock的区别和联系

Lock是java.util.concurrent.locks包下的接口，Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作，它能以更优雅的方式处理线程同步问题，我们拿Java线程(二)中的一个例子简单的实现一下和sychronized一样的效果，代码如下：

[java]view plain

从结果可以看出实现了我们的需求，这只是锁的基本用法，锁的机制还需要继续深入学习。

本文来自：高爽|Coder，原文地址：http://blog.csdn.net/ghsau/article/details/7461369，转载请注明。

在java中有两种方式实现原子性操作（即同步操作）：
1）使用同步关键字synchronized
2）使用lock锁机制其中也包括相应的读写锁

package com.xiaohao.test;

import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Test {
public static void main(String[] args) {
final LockTest lock=new LockTest();
//输出张三
new Thread(){
public void run(){
lock.test("张三张三张三张三张三张三张三张三张三张三");
}
}.start();

//输出李四
new Thread(){
public void run(){
lock.test("李四李四李四李四李四李四李四李四李四李四");System.out.println
(" ---------------------------------------------------------------");
}
}.start();


//---------------------------------------------------------------
//模拟写入数据的
for (int i = 0; i < 3; i++) {
new Thread(){
public void run() {
for (int j = 0; j < 5; j++) {
// lock.set(new Random().nextInt(30));
lock.set2(new Random().nextInt(30));

}
}
}.start();

}
//模拟读取数据的
for (int i = 0; i < 3; i++) {
new Thread(){
public void run() {
for (int j = 0; j < 5; j++) {
// lock.get();
lock.get2();
}
}
}.start();
}


}
}

class LockTest{
private Lock lock=new ReentrantLock(); //创建普通的锁
private ReadWriteLock readWriteLock=new ReentrantReadWriteLock();//创建读写锁
private int data;// 共享数据


//实现同步的方法一 使用同步关键字 synchronized
public synchronized void test(String name){
//下面的相关操作是一个原子性的操作
// lock.lock();// 得到锁
try {
for(int i = 0; i < name.length(); i++) {
System.out.print(name.charAt(i));
}
} finally {
// lock.unlock();// 释放锁
}
}
//实现同步的方法二 使用lock锁机制
public void test2(String name){
//下面的相关操作是一个原子性的操作
lock.lock();// 得到锁
try {
for(int i = 0; i < name.length(); i++) {
System.out.print(name.charAt(i));
}
} finally {
lock.unlock();// 释放锁
}
}


//使用set方法模拟写入数据
//使用 synchronized 实现了读读，写写，读写之间的互斥 ，但读读之间的互斥是没有什么必要的
public synchronized void set(int data){
System.out.println(Thread.currentThread().getName() + "准备写入数据");
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.data = data;
System.out.println(Thread.currentThread().getName() + "写入" + this.data);
}

//使用get方法模拟读取数据
//使用 synchronized 实现了读读，写写，读写之间的互斥 ，但读读之间的互斥是没有什么必要的
public synchronized void get() {
System.out.println(Thread.currentThread().getName() + "准备读取数据");
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "读取" + this.data);
}


//使用set方法模拟写入数据
//使用 读写锁实现了写写，读写之间的互斥 ，但读读之间的互斥是没有什么必要的
public void set2(int data){
readWriteLock.writeLock().lock();//获取写入锁
try{
System.out.println(Thread.currentThread().getName() + "准备写入数据");
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.data = data;
System.out.println(Thread.currentThread().getName() + "写入" + this.data);
}
finally{
readWriteLock.writeLock().unlock();
}
}


//使用get方法模拟读取数据
//使用 读写锁实现了写写，读写之间的互斥 ，但读读之间的互斥是没有什么必要的
public void get2() {
//获取相应的读锁
readWriteLock.readLock().lock();
try{
System.out.println(Thread.currentThread().getName() + "准备读取数据");
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "读取" + this.data);
}
finally{
// 释放相应的写锁
readWriteLock.readLock().unlock();
}
}

}

线程同步经典版：

package com.xiaohao.test;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Test2{

public static void main(String[] args){

final LockTest2 lockTest=new LockTest2();

for(int i=0;i<3;i++) {

new Thread(){

public void run(){

try {

for (int j = 0; j < 3; j++) {

lockTest.setValue();

} } catch (InterruptedException e) {

// TODO Auto-generated catch block e.printStackTrace();

}

}

}.start();

}

for(int i=0;i<3;i++) {

new Thread(){

public void run(){

try {

for (int j = 0; j < 3; j++) {

lockTest.getValue();

}

} catch (InterruptedException e)

{ // TODO Auto-generated catch block e.printStackTrace(); }

}

}.start();

}

}

}

class LockTest2 {

int data=0;

ReentrantReadWriteLock lock= new ReentrantReadWriteLock();// 锁对象

public void setValue() throws InterruptedException{

lock.writeLock().lock();

System.out.println("正在使用写锁......");

data=(int) (Math.random()*10);

System.out.println("正在写入："+data);

Thread.sleep(500);

System.out.println("写锁调用完毕---------------------------");

lock.writeLock().unlock(); }

public void getValue() throws InterruptedException{

lock.readLock().lock();

System.out.println("正在使用读锁...........................................");

System.out.println("正在读入："+data); Thread.sleep(500);

System.out.println("读锁调用完毕......");

lock.readLock().unlock();

}

}

**** 当一个线程进入了一个对象是的synchronized方法，那么其它线程还能掉否调用此对象的其它方法？

这个问题需要分几种情况进行讨论。

1）查看其它方法是否使用了同步关键字(synchronized)修饰，如果没有的话就可以调用相关的方法。

2）在当前synchronized方法中是否调用了wait方法，如果调用了，则对应的锁已经释放，可以访问了。

3）如果其它方法也使用synchronized修饰，并且当前同步方法中没有调用wait方法的话，这样是不允许访问的。

4）如果其它方法是静态方法的话，由于静态方法和对象是扯不上什么关系，对于静态同步方法而言，其对应的同步监视器为当前类的字节码

所以肯定可以访问的了。

㈦ Java多线程初学者指南（10）：使用Synchronized关键字同步类方法

要想解决 脏数据 的问题 最简单的方法就是使用synchronized关键字来使run方法同步 代码如下

publicsynchronizedvoidrun(){}

从上面的代码可以看出 只要在void和public之间加上synchronized关键字 就可以使run方法同步 也就是说 对于同一个Java类的对象实例 run方法同时只能被一个线程调用 并当前的run执行完后 才能被其他的线程调用 即使当前线程执行到了run方法中的yield方法 也只是暂停了一下 由于其他线程无法执行run方法 因此 最终还是会由当前的线程来继续执行 先看看下面的代码

sychronized关键字只和一个对象实例绑定

classTest{publicsynchronizedvoidmethod(){}纳察}{privateTesttest;publicvoidrun() { thod(); } publicSync(Testtest) { this test=test; } publicstaticvoidmain(String[]args)throwsException { Testtest =newTest(); Testtest =newTest(); Syncsync =newSync(test ); Syncsync =newSync(test ); newThread(sync ) start(); newThread(sync ) start(); } }

在Test类中的method方法是同步的 但上面的代码建立了两个Test类的实例 因此 test 和test 的method方法是分别执行的 要想让method同步 必须在建立仿茄升Sync类的实例时向它的构造方法中传入同一个Test类的实例 如下面的代码所示

Syncsync =newSync(test );

不仅可以使用synchronized来同步非静态方法 也可以使用synchronized来同步静态方法 如可以按如下方式来定义method方法

classTest{ (){}}

建立Test类的对象实例如下

Testtest=newTest();

对于静态方法来说 只要加上了synchronized关键字 这个方法就是同步的 无论是使用thod（） 还是使用thod（）来调用method方法 method都是同步的 并不存在非静态方法的多个实例的问题

在 种设计模式中的单件（Singleton）模式如果按传统的方法设计 也是线程不安全的 下面的代码是一个线程不安全的单件模式

packagetest;//线程安全的Singleton模式classSingleton{privatestaticSingletonsample;privateSingleton(){备老}(){if(sample==null){Thread yield();//为了放大Singleton模式的线程不安全性sample=newSingleton();}returnsample;}}{publicvoidrun(){Singletonsingleton=Singleton getInstance();System out println(singleton hashCode());}publicstaticvoidmain(String[]args){Threadthreads[]=newThread[ ];for(inti= ;i<threads length;i++)threads[i]=newMyThread();for(inti= ;i<threads length;i++)threads[i] start();}}

在上面的代码调用yield方法是为了使单件模式的线程不安全性表现出来 如果将这行去掉 上面的实现仍然是线程不安全的 只是出现的可能性小得多

程序的运行结果如下

上面的运行结果可能在不同的运行环境上有所有同 但一般这五行输出不会完全相同 从这个输出结果可以看出 通过getInstance方法得到的对象实例是五个 而不是我们期望的一个 这是因为当一个线程执行了Thread yield（）后 就将CPU资源交给了另外一个线程 由于在线程之间切换时并未执行到创建Singleton对象实例的语句 因此 这几个线程都通过了if判断 所以 就会产生了建立五个对象实例的情况（可能创建的是四个或三个对象实例 这取决于有多少个线程在创建Singleton对象之前通过了if判断 每次运行时可能结果会不一样）

要想使上面的单件模式变成线程安全的 只要为getInstance加上synchronized关键字即可 代码如下

(){}

当然 还有更简单的方法 就是在定义Singleton变量时就建立Singleton对象 代码如下

=newSingleton();

然后在getInstance方法中直接将sample返回即可 这种方式虽然简单 但不知在getInstance方法中创建Singleton对象灵活 读者可以根据具体的需求选择使用不同的方法来实现单件模式

在使用synchronized关键字时有以下四点需要注意

synchronized关键字不能继承

虽然可以使用synchronized来定义方法 但synchronized并不属于方法定义的一部分 因此 synchronized关键字不能被继承 如果在父类中的某个方法使用了synchronized关键字 而在子类中覆盖了这个方法 在子类中的这个方法默认情况下并不是同步的 而必须显式地在子类的这个方法中加上synchronized关键字才可以 当然 还可以在子类方法中调用父类中相应的方法 这样虽然子类中的方法不是同步的 但子类调用了父类的同步方法 因此 子类的方法也就相当于同步了 这两种方式的例子代码如下

在子类方法中加上synchronized关键字

classParent{ publicsynchronizedvoidmethod(){}}classChildextendsParent{ publicsynchronizedvoidmethod(){}}

在子类方法中调用父类的同步方法

classParent{ publicsynchronizedvoidmethod(){}}classChildextendsParent{publicvoidmethod(){thod();}}

在定义接口方法时不能使用synchronized关键字

构造方法不能使用synchronized关键字 但可以使用下节要讨论的synchronized块来进行同步

synchronized可以自由放置

在前面的例子中使用都是将synchronized关键字放在方法的返回类型前面 但这并不是synchronized可放置唯一位置 在非静态方法中 synchronized还可以放在方法定义的最前面 在静态方法中 synchronized可以放在static的前面 代码如下

publicsynchronizedvoidmethod();synchronizedpublicvoidmethod();();();();

但要注意 synchronized不能放在方法返回类型的后面 如下面的代码是错误的

publicvoidsynchronizedmethod();();

synchronized关键字只能用来同步方法 不能用来同步类变量 如下面的代码也是错误的

publicsynchronizedintn= ;publicstaticsynchronizedintn= ;

虽然使用synchronized关键字同步方法是最安全的同步方式 但大量使用synchronized关键字会造成不必要的资源消耗以及性能损失 虽然从表面上看synchronized锁定的是一个方法 但实际上synchronized锁定的是一个类 也就是说 如果在非静态方法method 和method 定义时都使用了synchronized 在method 未执行完之前 method 是不能执行的 静态方法和非静态方法的情况类似 但静态和非静态方法不会互相影响 看看如下的代码

packagetest;publicclassMyThread extendsThread{publicStringmethodName;publicstaticvoidmethod(Strings){System out println(s);while(true);}publicsynchronizedvoidmethod (){method( 非静态的method 方法 );}publicsynchronizedvoidmethod (){method( 非静态的method 方法 );} (){method( 静态的method 方法 );} (){method( 静态的method 方法 );}publicvoidrun(){try{getClass() getMethod(methodName) invoke(this);}catch(Exceptione){}}publicstaticvoidmain(String[]args)throwsException{MyThread myThread =newMyThread ();for(inti= ;i<= ;i++){thodName= method +String valueOf(i);newThread(myThread ) start();sleep( );}}}

运行结果如下

非静态的method 方法静态的method 方法

㈧ java类内多个函数如何同步

线程间的通讯首要的方式就是对字段及其字段所引用的对象的共享访问。这种通信方式是及其高效的，但是也是导致了可能的错误：线程间相互干涉和内存一致性的问题。避免出现这两种错误的方法就是同步。

线程间相互干扰描述了当多个线程访问共享数据时可能出现的错误。
内存一致性错误描述的了共享内存可能导致的错误。
同步方法（Synchronized method）描述了一种简单的可以有效防止线程间相互干扰及其内存一致性错误的方法。
明锁及同步描述了一种更加通用的同步方法，以及同步是如何基于明锁而实现的。
原子性描述了不能被其它线程干扰的操作。

线程间的相互干扰
考虑下面的一个简单的类Counter：

[java] view plain
class Counter {
private int c = 0;

public void increment() {
c++;
}

public void decrement() {
c--;
}

public int value() {
return c;
}
}

不难看出，其中的increment()方法用来对c加1；decrement()方法用来对c减1。然而，有多个线程中都存在对某个Counter对象的引用，那么线程间的干扰就可能导致出现我们不想要的结果。

线程间的干扰出现在多个线程对同一个数据进行多个操作的时候，也就是出现了“交错”。山纯局这就意味着操作是由多个步骤构成的，而此时，裤仿在这多个步骤的执行上出现了叠加。

Counter类对象的操作貌似不可能出现这种“交错”，因为其中的两个关于c的操作都很简单，只有一条语句。然而，即使是一条语句也是会被VM翻译成多个步骤的。在这里，我们不深究VM具体上上面的操作翻译成了什么样的步骤。只需要知道即使简单的c++这样的表达式也是会被翻译成三个步骤的：
1. 获取c的当前值。
2. 对其当前值加1。
3. 将增加后的值存储到c中。

表达式c--也是会被按照同样的方式进行翻译，只不过第二步变成了减1，而不是加1。
假定线程A中调用increment方法，线逗让程B中调用decrement方法，而调用时间基本上相同。如果c的初始值为0，那么这两个操作的“交错”顺序可能如下：
1. 线程A：获取c的值。
2. 线程B：获取c的值。
3. 线程A：对获取到的值加1；其结果是1。
4. 线程B：对获取到的值减1；其结果是-1。
5. 线程A：将结果存储到c中；此时c的值是1。
6. 线程B：将结果存储到c中；此时c的值是-1。
这样线程A计算的值就丢失了，也就是被线程B的值覆盖了。上面的这种“交错”只是一种可能性。在不同的系统环境中，有可能是B线程的结果丢失了，或者是根本就不会出现错误。由于这种“交错”是不可预测的，线程间相互干扰造成的缺陷是很难定位和修改的。

内存一致性错误

内存一致性错误发生在不同线程对同一数据产生不同的“见解”。导致内存一致性错误的原因很负责，超出了本文的描述范围。庆幸的是，程序员并不需要知道出现这些原因的细节。我们需要的只是一种可以避免这种错误的方法。

避免出现内存一致性错误的关键在于理解“先后顺序”关系。这种关系是一种简单的方法，能够确保一条语句对内存的写操作对于其它特定的语句都是可见的。为了理解这点，我们可以考虑如下的示例。假定定义了一个简单的int类型的字段并对其进行了初始化：
int counter = 0;
该字段由两个线程共享：A和B。假定线程A对counter进行了自增操作：
counter++;
然后，线程B输出counter的值：
System.out.println(counter);

如果以上两条语句是在同一个线程中执行的，那么输出的结果自然是1。但是如果这两条语句是在两个不同的线程中，那么输出的结构有可能是0。这是因为没有保证线程A对counter的修改对线程B来说是可见的。除非程序员在这两条语句间建立了一定的“先后顺序”。

我们可以采取多种方式建立这种“先后顺序”。使用同步就是其中之一，这点我们将会在下面的小节中看到。

到目前为止，我们已经看到了两种建立这种“先后顺序”的方式：

当一条语句中调用了Thread.start()方法，那么每一条和该语句已经建立了“先后顺序”的语句都和新线程中的每一条语句有着这种“先后顺序”。引入并创建这个新线程的代码产生的结果对该新线程来说都是可见的。
当一个线程终止了并导致另外的线程中调用join的语句回，那么此时这个终止了的线程中执行了的所有语句都和随后的join语句随后的所有语句建立了这种“先后关系”。也就是说终止了的线程中的代码效果对调用join方法的线程来说是可见。

关于哪些操作可以建立这种“先后关系”，更多的信息请参阅“java.util.concurrent包的概要说明”。

同步方法

Java编程语言中提供了两种基本的同步用语：同步方法和同步语句。同步语句相对而言更为复杂一些，我们将在下一小节中进行描述。本节重点讨论同步方法。

我们只需要在声明方法的时候增加关键字synchronized即可：

[java] view plain
public class SynchronizedCounter {
private int c = 0;
public synchronized void increment() {
c++;
}
public synchronized void decrement() {
c--;
}
public synchronized int value() {
return c;
}
}

如果count 是SynchronizedCounter类的实例，设置其方法为同步方法将有一下两个效果：

首先，不可能出现对同一对象的同步方法的两个调用的“交错”。当一个线程在执行一个对象的同步方式的时候，其他所有的调用该对象的同步方法的线程对会被挂起，直到第一个线程对该对象操作完毕。
其次，当一个同步方法退出时，会自动与该对象的后续同步方法间建立“先后顺序”的关系。这就确保了对该对象的修改对其他线程是可见的。

注意：构造函数不能为同步的——在构造函数前使用synchronized关键字将导致语义错误。同步构造函数是没有意义的。这是因为只有创建该对象的线程才能调用其构造函数。
警告：在创建多个线程共享的对象时，要特别小心对该对象的引用不能过早地“泄露”。例如，假定我们想要维护一个保存类的所有实例的列表instances。我们可能会在构造函数中这样写到：
instances.add(this);
但是，其他线程可会在该对象的构造完成之前就访问该对象。

同步方法是一种简单的可以避免线程相互干扰和内存一致性错误的策略：如果一个对象对多个线程都是可见的，那么所有对该对象的变量的读写都应该是通过同步方法完成的（一个例外就是final字段，他在对象创建完成后是不能被修改的，因此，在对象创建完毕后，可以通过异步的方法对其进行安全的读取）。这种策略是有效的，但是可能导致“liveness”问题。这点我们会在本课程的后面进行描述。

内部锁及同步

同步是构建在被称为“内部锁或者是监视锁”的内部实体上的。（在API中通常被称为是“监视器”。）内部锁在两个方面都扮演着重要的角色：保证对对象访问的排他性和建立也对象可见性相关的重要的“先后顺序”。

每一个对象都有一个与之相关联动的内部锁。按照传统的做法，当一个线程需要对一个对象的字段进行排他性访问并保持访问的一致性时，他必须在访问前先获取该对象的内部锁，然后才能访问之，最后释放该内部锁。在线程获取对象的内部锁到释放对象的内部锁的这段时间，我们说该线程拥有该对象的内部锁。只要有一个线程已经拥有了一个内部锁，其他线程就不能在拥有该锁了。其他线程将会在试图获取该锁的时候被阻塞了。

当一个线程释放了一个内部锁，那么就会建立起该动作和后续获取该锁之间的“先后顺序”。

同步方法中的锁
当一个线程调用一个同步方法的时候，他就自动地获得了该方法所属对象的内部锁，并在方法返回的时候释放该锁。即使是由于出现了没有被捕获的异常而导致方法返回，该锁也会被释放。

我们可能会感到疑惑：当调用一个静态的同步方法的时候会怎样了，静态方法是和类相关的，而不是和对象相关的？ 在这种情况下，线程获取的是该类的类对象的内部锁。这样对于静态字段的方法是通过一个和类的实例的锁相区分的另外的锁来进行的。

同步语句
另外一种创建同步代码的方式就是使用同步语句。和同步方法不同，使用同步语句是必须指明是要使用哪个对象的内部锁：

[java] view plain
public void addName(String name) {
synchronized(this) {
lastName = name;
nameCount++;
}
nameList.add(name);
}

在上面的示例中，方法addName需要对lastName和nameCount的修改进行同步，还要避免同步调用其他对象的方法（在同步代码段中调用其他对象的方法可能导致“Liveness”中描述的问题）。如果没有使用同步语句，那么将不得不使用一个单独的，未同步的方法来完成对nameList.add的调用。

在改善并发性时，巧妙地使用同步语句能起到很大的帮助作用。例如，我们假定类MsLunch有两个实例字段，c1和c2，这两个变量绝不会一起使用。所有对这两个变量的更新都需要进行同步。但是没有理由阻止对c1的更新和对c2的更新出现交错——这样做会创建不必要的阻塞，进而降低并发性。此时，我们没有使用同步方法或者使用和this相关的锁，而是创建了两个单独的对象来提供锁。

[java] view plain
public class MsLunch {
private long c1 = 0;
private long c2 = 0;
private Object lock1 = new Object();
private Object lock2 = new Object();
public void inc1() {
synchronized(lock1) {
c1++;
}
}
public void inc2() {
synchronized(lock2) {
c2++;
}
}
}

采用这种方式时需要特别的小心。我们必须绝对确保相关字段的访问交错是完全安全的。

同步的重入
回忆前面提到的：线程不能获取已经被别的线程获取的锁。单丝线程可以获取自身已经拥有的锁。允许一个线程能重复获得同一个锁就称为同步重入。它是这样的一种情况：在同步代码中直接或者间接地调用了还有同步代码的方法，两个同步代码段中使用的是同一个锁。如果没有同步重入，在编写同步代码时需要额外的小心，以避免线程将自己阻塞。

原子性

在编程中，原子性动作就是指一次性有效完成的动作。原子性动作是不能在中间停止的：要么一次性完全执行完毕，要么就不执行。在动作没有执行完毕之前，是不会产生可见结果的。

通过前面的示例，我们已经发现了诸如c++这样的自增表达式并不属于原子操作。即使是非常见到的表达式也定义了负责的动作，这些动作可以被解释成许多别的动作。然而，的确存在一些原子操作的：

对几乎所有的原生数据类型变量的读写（除了long和都变了外）以及引用变量的读写都是原子的。
对所有声明为volatile的变量的读写都是原子的，包括long和double类型。

原子性动作是不会出现交错的，因此，使用这些原子性动作时不用考虑线程间的干扰。然而，这并不意味着可以移除对原子操作的同步。因为内存一致性错误还是有可能出现的。使用volatile变量可以减少内存一致性错误的风险，因为任何对volatile变量的写操作都和后续对该变量的读操作建立了“先后顺序”。这就意味着对volatile类型变量的修改对于别的线程来说是可见的。更重要的是，这意味着当一个线程读取一个volatile类型的变量是，他看到的不仅仅是对该变量的最后一次修改，还看到了导致这种修改的代码带来的其他影响。

使用简单的原子变量访问比通过同步代码来访问变量更高效，但是需要程序员的更多细心考虑，以避免内存一致性错误。这种额外的付出是否值得完全取决于应用程序的大小和复杂度。

在包java.util.concurrent中的一些类提供了原子方法，这些方法不依赖于同步。我们会在章节：High Level Concurrency Objects中进行讨论。

㈨ java 总结几种线程异步转同步的方法

以Java语言为例：
用synchronized关键字修饰同步方法。
同步有几种实现方法分别是synchronized,wait与notify
wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
同步是多线程中的重要概念。同步的使用可以保证在多线程运行的环境中，程序不会产生设计之外的错误结果。同步的实现方式有两种，同步方法和同步块，这两种方式都要用到synchronized关键字。
给一个方法增加synchronized修饰符之后就可以使它成为同步方法，这个方法可以是静态方法和非静态方法，但是不能是抽象类的抽象方法，也不能是接口中的接口方法。下面代码是一个同步方法的示例：
public synchronized void aMethod() {
// do something
}
public static synchronized void anotherMethod() {
// do something
}

线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时，这个对象的所有同步方法都被锁定了，在此期间，其他任何线程都不能访问这个对象的任意一个同步方法，直到这个线程执行完它所调用的同步方法并从中退出，从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后，其他线程是可以访问这个对象的所有异步方法的。
同步块是通过锁定一个指定的对象，来对同步块中包含的代码进行同步；而同步方法是对这个方法块里的代码进行同步，而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法呢？那么线程锁定的就不是这个类的对象了，也不是这个类自身，而是这个类对应的java.lang.Class类型的对象。同步方法和同步块之间的相互制约只限于同一个对象之间，所以静态同步方法只受它所属类的其它静态同步方法的制约，而跟这个类的实例（对象）没有关系。

㈩ java中线程同步的几种方法

线程同步主要有以下种方法(示例中是实现计数的功能)：

1、同步方法，即使用synchronized关键字修饰方法，例如：

publicsynchronizedvoidadd(intc){...}

2、同步代码块，即有synchronized关键字修饰的语句块，例如：

publicvoidaddAndGet(intc){
synchronized(this){
count+=c;
}
}

3、使用特殊域变量(volatile)实现线程同步，该方法不能保证绝对的同步。

例如：privatevolatileintcount=0;

4、使用锁实现线程同步，例如：

privateLocklock=newReentrantLock();
publicvoidadd(intc){
lock.lock();//上锁
try{
count+=c;
}finally{
lock.unlock();//解锁
}
}

5、使用原子变量实现线程同步，在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类，例如：

privateAtomicIntegercount=newAtomicInteger(1);
publicvoidadd(intc){
count.addAndGet(c);
}

6、使用局部变量实现线程同步，如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本， 副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。

ThreadLocal 类的常用方法

new ThreadLocal<T>() : 创建一个线程本地变量

get() : 返回此线程局部变量的当前线程副本中的值

initialValue() : 返回此线程局部变量的当前线程的"初始值"

set(T value) : 将此线程局部变量的当前线程副本中的值设置为value

示例代码：

privatestaticThreadLocal<Integer>count=newThreadLocal<Integer>(){
@Override
protectedIntegerinitialValue(){
return1;
}
};

publicvoidadd(intc){
count.set(count.get()+c);
}

7、使用阻塞队列实现，例如LinkedBlockingQueue，具体使用可网络LinkedBlockingQueue的用法或查看java文档。