java同步异步基础【转】

-脏读：脏读又称无效数据的读出，是指在数据库访问中，事务T1将某一值修改，然后事务T2读取该值，此后T1因为某种原因撤销对该值的修改，这就导致了T2所读取到的数据是无效的。脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。因为这个数据是还没有提交的数据，那么另外一个事务读到的这个数据是脏数据，依据脏数据所做的操作可能是不正确的

 

-java 同步和异步 很经典

举个例子：普通B/S模式（同步）AJAX技术（异步） 

         同步：提交请求->等待服务器处理->处理完毕返回 这个期间客户端浏览器不能干任何事 

         异步: 请求通过事件触发->服务器处理（这是浏览器仍然可以作其他事情）->处理完毕

 

-同步就是你叫我去吃饭，我听到了就和你去吃饭；如果没有听到，你就不停的叫，直到我告诉你听到了，才一起去吃饭。 

-异步就是你叫我，然后自己去吃饭，我得到消息后可能立即走，也可能等到下班才去吃饭。 

所以，要我请你吃饭就用同步的方法，要请我吃饭就用异步的方法，这样你可以省钱。

 

-同步:发送一个请求,等待返回,然后再发送下一个请求 

-异步:发送一个请求,不等待返回,随时可以再发送下一个请求 

-并发:同时发送多个请求

 

Java同步、异步相关知识点

一、关键字：

 

thread（线程）、thread-safe(线程安全)、intercurrent（并发的）

synchronized(同步的)、asynchronized(异步的)、

volatile（易变的）、atomic（原子的）、share（共享）

 

1、  什么时候必须同步？什么叫同步？如何同步？

 

    要跨线程维护正确的可见性，只要在几个线程之间共享非 final 变量，就必须使用 synchronized（或 volatile）以确保一个线程可以看见另一个线程做的更改。

为了在线程之间进行可靠的通信，也为了互斥访问，同步是必须的。这归因于java语言规范的内存模型，它规定了：一个线程所做的变化何时以及如何变成对其它线程可见。

因为多线程将异步行为引进程序，所以在需要同步时，必须有一种方法强制进行。例如：如果2个线程想要通信并且要共享一个复杂的数据结构，如链表，此时需要确保它们互不冲突，也就是必须阻止B线程在A线程读数据的过程中向链表里面写数据（A获得了锁，B必须等A释放了该锁）。为了达到这个目的，java在一个旧的的进程同步模型——监控器（Monitor）的基础上实现了一个巧妙的方案：监控器是一个控制机制，可以认为是一个很小的、只能容纳一个线程的盒子，一旦一个线程进入监控器，其它的线程必须等待，直到那个线程退出监控为止。通过这种方式，一个监控器可以保证共享资源在同一时刻只可被一个线程使用。这种方式称之为同步。（一旦一个线程进入一个实例的任何同步方法，别的线程将不能进入该同一实例的其它同步方法，但是该实例的非同步方法仍然能够被调用）。

    错误的理解：同步嘛，就是几个线程可以同时进行访问。

    -同步和多线程关系：没多线程环境就不需要同步;有多线程环境也不一定需要同步。

    -同步和互斥的关系：相交进程之间的关系主要有两种，同步与互斥。所谓互斥，是指散步在不同进程之间的若干程序片断，当某个进程运行其中一个程序片段时，其它进程就不能运行它 们之中的任一程序片段，只能等到该进程运行完这个程序片段后才可以运行。所谓同步，是指散步在不同进程之间的若干程序片断，它们的运行必须严格按照规定的 某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。

　　显然，同步是一种更为复杂的互斥，而互斥是一种特殊的同步。

　　也就是说互斥是两个线程之间不可以同时运行，他们会相互排斥，必须等待一个线程运行完毕，另一个才能运行，而同步也是不能同时运行，但他是必须要安照某种次序来运行相应的线程（也是一种互斥）！

 

    -互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。

　　-同步：是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源。

 

锁提供了两种主要特性：互斥（mutual exclusion）和可见性（visibility）。

    -互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。

    -可见性要更加复杂一些，它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的 —— 如果没有同步机制提供的这种可见性保证，线程看到的共享变量可能是修改前的值或不一致的值，这将引发许多严重问题(说得不雅一点，就是：一个人上了厕所，另外一个人接着进去，要能闻到臭味。)

 

    小结：为了防止多个线程并发对同一数据的修改，所以需要同步，否则会造成数据不一致（就是所谓的：线程安全。如java集合框架中 Hashtable和Vector是线程安全的。我们的大部分程序都不是线程安全的，因为没有进行同步，而且我们没有必要，因为大部分情况根本没有多线程环境）。

 

2、  什么叫原子的（原子操作）？

 

     Java原子操作是指：不会被打断地的操作。（就是做到互斥 和可见性？！）

     那难道原子操作就可以真的达到线程安全同步效果了吗？实际上有一些原子操作不一定是线程安全的。那么，原子操作在什么情况下不是线程安全的呢？也许是这个原因导致的：java线程允许线程在自己的内存区保存变量的副本。允许线程使用本地的私有拷贝进行工作而非每次都使用主存的值是为了提高性能（本人愚见：虽然原子操作是线程安全的，可各线程在得到变量（读操作）后，就是各自玩弄自己的副本了，更新操作（写操作）因未写入主存中，导致其它线程不可见）。

 

     那该如何解决呢？因此需要通过java同步机制。

 

     在java中，32位或者更少位数的赋值是原子的。在一个32位的硬件平台上，除了double和long型的其它原始类型通常都是使用32位进行表示，而double和long通常使用64位表示。另外，对象引用使用本机指针实现，通常也是32位的。对这些32位的类型的操作是原子的。

 

     这些原始类型通常使用32位或者64位表示，这又引入了另一个小小的神话：原始类型的大小是由语言保证的。这是不对的。java语言保证的是原始类型的表数范围而非JVM中的存储大小。因此，int型总是有相同的表数范围。在一个JVM上可能使用32位实现，而在另一个JVM上可能是64位的。在此再次强调：在所有平台上被保证的是表数范围，32位以及更小的值的操作是原子的。

 

3、  不要搞混了：同步、异步

 

     举个例子：普通B/S模式（同步）AJAX技术（异步）

 

     同步：提交请求->等待服务器处理->处理完返回 这个期间客户端浏览器不能干任何事

     异步：请求通过事件触发->服务器处理（这是浏览器仍然可以作其他事情）->处理完毕

 

     注：彼“同步”非此“同步”——我们说的java中的那个共享数据同步（synchronized）一个同步的对象是指行为（动作），一个是同步的对象是指物质（共享数据）。

 

4、  Java同步机制有4种实现方式：（部分引用网上资源）

 

①    ThreadLocal ② synchronized( ) ③ wait() 与 notify() ④ volatile

 

     目的：都是为了解决多线程中的对同一变量的访问冲突

 

ThreadLocal

    ThreadLocal 保证不同线程拥有不同实例，相同线程一定拥有相同的实例，即为每一个使用该变量的线程提供一个该变量值的副本，每一个线程都可以独立改变自己的副本，而不是与其它线程的副本冲突。

 

    优势：提供了线程安全的共享对象

    与其它同步机制的区别：同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信；而 ThreadLocal 是隔离多个线程的数据共享，从根本上就不在多个线程之间共享资源，这样当然不需要多个线程进行同步了。

 

volatile

     volatile 修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。

 

     优势：这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

     缘由：Java 语言规范中指出，为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。而 volatile 关键字就是提示 VM ：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。

     

     使用技巧：在两个或者更多的线程访问的成员变量上使用 volatile 。当要访问的变量已在 synchronized 代码块中，或者为常量时，不必使用。

     

     线程为了提高效率，将某成员变量(如A)拷贝了一份（如B），线程中对A的访问其实访问的是B。只在某些动作时才进行A和B的同步，因此存在A和B不一致的情况。volatile就是用来避免这种情况的。 volatile告诉jvm，它所修饰的变量不保留拷贝，直接访问主内存中的（读操作多时使用较好；线程间需要通信，本条做不到）

 

   volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现 volatile 变量的最新值。Volatile 变量可用于提供线程安全，但是只能应用于非常有限的一组用例：多个变量之间或者某个变量的当前值与修改后值之间没有约束。

 

   您只能在有限的一些情形下使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件：

(1)对变量的写操作不依赖于当前值；

(2)该变量没有包含在具有其他变量的不变式中。

 

Synchronized既保证了多线程的并发有序性（即同步），又保证了多线程的内存可见性。

 

--------------------------------------------------------------------------------------------------------------------------------------------------------------------

比较volatile & synchronized ==> 

关于volatile & synchronized的比较另见博文：http://blog.csdn.net/ghsau/article/details/7424694

 

　　恐怕比较一下volatile和synchronized的不同是最容易解释清楚的。volatile是变量修饰符，而synchronized则作用于一段代码或方法；看如下三句get代码：

int i1;int geti1() {return i1;}

volatile int i2;int geti2() {return i2;}

int i3; synchronizedint geti3() {return i3;}

 

　　geti1()得到存储在当前线程中i1的数值。多个线程有多个i1变量拷贝，而且这些i1之间可以互不相同。换句话说，另一个线程可能已经改变了它线程内的i1值，而这个值可以和当前线程中的i1值不相同。事实上，Java有个思想叫“主”内存区域，这里存放了变量目前的“准确值”。每个线程可以有它自己的变量拷贝，而这个变量拷贝值可以和“主”内存区域里存放的不同。因此实际上存在一种可能：“主”内存区域里的i1值是1，线程1里的i1值是2，线程2里的i1值是3——这在线程1和线程2都改变了它们各自的i1值，而且这个改变还没来得及传递给“主”内存区域或其他线程时就会发生。

　　而geti2()得到的是“主”内存区域的i2数值。用volatile修饰后的变量不允许有不同于“主”内存区域的变量拷贝。换句话说，一个变量经volatile修饰后在所有线程中必须是同步的；任何线程中改变了它的值，所有其他线程立即获取到了相同的值。理所当然的，volatile修饰的变量存取时比一般变量消耗的资源要多一点，因为线程有它自己的变量拷贝更为高效。

　　既然volatile关键字已经实现了线程间数据同步，又要synchronized干什么呢？呵呵，它们之间有两点不同。首先，synchronized获得并释放监视器——如果两个线程使用了同一个对象锁，监视器能强制保证代码块同时只被一个线程所执行——这是众所周知的事实。但是，synchronized也同步内存：事实上，synchronized在“主”内存区域同步整个线程的内存。因此，执行geti3()方法做了如下几步：

1. 线程请求获得监视this对象的对象锁（假设未被锁，否则线程等待直到锁释放）

2. 线程内存的数据被消除，从“主”内存区域中读入（Java虚拟机能优化此步。。。[后面的不知道怎么表达,汗]）

3. 代码块被执行

4. 对于变量的任何改变现在可以安全地写到“主”内存区域中（不过geti3()方法不会改变变量值）

5. 线程释放监视this对象的对象锁

　　因此volatile只是在线程内存和“主”内存间同步某个变量的值，而synchronized通过锁定和解锁某个监视器同步所有变量的值。显然synchronized要比volatile消耗更多资源。

--------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

sleep() vs wait()

  sleep()是线程类（Thread）的静态方法，导致此线程睡眠执行指定时间，把执行机会给其他线程，但是监控状态依然保持，到时候会自动恢复。调用sleep不会释放对象锁。

  yield()是线程类（Thread）的静态方法，不能保障太多事情，他只会让处于运行状态的当前线程回到可运行状态，使得同优先级的线程有机会执行。但是无法保证yield()达到目的，因为让步的线程还有可能被调度程序再次选中。

  wait()是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或 notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

（如果变量被声明为volatile，在每次访问时都会和主存一致；如果变量在同步方法或者同步块中被访问，当在方法或者块的入口处获得锁以及方法或者块退出时释放锁时变量被同步。）

 

例子：Demo1

package test.thread;

 

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();

        }

    }

}

 

 

 

 

 

/**

 

    执行method()方法结果：

       begin Thread-0

       begin Thread-2

       begin Thread-1

       end Thread-1

       end Thread-0

       end Thread-2

 

    说明了:在没有同步限制的条件下,多个线程可以同时进入一个对象的方法中操作。

    这样对共享可变数据是不安全的，即常说的：非线程安全（non thread-safe）。

*/

 

/**

    执行method1()/method2()/method3()方法结果(可能线程进入的顺序不同)：

       begin Thread-0

       end Thread-0

       begin Thread-1

       end Thread-1

       begin Thread-2

       end Thread-2

    说明了:在同步限制的条件下,同时只可有一个线程进入一个对象的方法中操作，其它线程必须等待先它的线程退出后才可进入。

    这样可保证共享可变数据是安全的，即常说的：线程安全（thread-safe ）。

*/

 

Demo2:

package test.thread;

import com.util.LogUtil;

 

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");

    }

}

 

class Callme{

    //有和没有synchronized的时候，结果是不一样的

    synchronized void test(){

       LogUtil.log("测试是否是：一旦一个线程进入一个实例的任何同步方法，别的线程将不能进入该同一实例的其它同步方法，但是该实例的非同步方法仍然能够被调用");

    }

 

    void nonsynCall(String msg){

       LogUtil.log("["+msg);

       LogUtil.log("]");

    }

 

    synchronized void synCall(String msg){

       LogUtil.logPrint("["+msg);

       LogUtil.log("]");

    }

}

 

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() {

       //target.nonsynCall(msg);

       target.synCall(msg);

       target.test();

    }

}

 

五、XXXX：

    写程序到现在，还没有自己写过需要多线程并发访问的。看看前公司的底层代码，也没怎么发现到什么多线程的知识。也许，应用层很少用到这些东西。下个阶段准备学习学习JDK的并发包。

 

    在oracle存储过程中，我要订制跟单方案，我首先要在规则表中查询跟单人数是否小于最大人数跟单人数（如果超过最大跟单人数就不订单），然后才可订制跟单，但是由于高并发性，实际跟单人数总是要超过最大跟单人数。怎样才能解决这个问题，有什么好的方案，高手帮忙解答一下。。。。谢过。。。不知道我说得是否能听懂

问题补充：

    看下存储过程代码：Count是不允许锁的！！！！！！！！在两个表中查询锁定还有用吗？？？？？？？看下看下

 SELECT COUNT(ai.autobuyid) INTO v_follnum FROM Autobuyinfo ai WHERE ai.gameid=pi_gameid AND ai.casttype=pi_casttype AND ai.superuserid=pi_superid AND ai.followtype=0;     

SELECT ar.maxfollownum INTO v_rulenum FROM Autobuyrule ar WHERE ar.gameid=pi_gameid AND ar.casttype=pi_casttype;                      

                IF v_follnum >= v_rulenum THEN 

                   po_errdesc:='订单人数已满，不可再订制跟单';

                   po_errcode:=-6;

                   raise DEFERROR;

                END IF;                   

                --添加自动跟单 

                INSERT INTO Autobuyinfo ai         (ai.autobuyid,ai.followu

最佳答案

    你这里要考虑并发与业务逻辑的一个平衡。但是事实上只能先保证业务正确，那么就需要对同一条记录（即同一个单子）进行线性操作了。

最简单的，利用oracle存储过程的事务原子性和行锁机制就可以解决。

比如：

create or replace procedure aaa( ...)

as

v_count number; 

begin

    ....

    select count(*) into v_count from tbl where id=123 for update; 

-- 利用for update锁住对应这个单号的这条记录。这样，在这个存储过程没有commit之前，别的存储过程对id号（你的单号）为123的记录的for update查询只能等待。

    ..... 处理你的业务逻辑；

    update tbl set amout=amout+1 where id=123; 这里把跟单人数加1.

   ... 其他逻辑

end;

/