Java线程的同步和异步的区别

时间:2021-07-24 18:32:19

1.

                                                                同步与异步

   多线程并发时,多个线程同时请求同一个资源,必然导致此资源的数据不安全,A线程修改了B线

程的处理的数据,而B线程又修改了A线程处理的数理。显然这是由于全局资源造成的,有时为了解

决此问题,优先考虑使用局部变量,退而求其次使用同步代码块,出于这样的安全考虑就必须牺牲

系统处理性能,加在多线程并发时资源挣夺最激烈的地方,这就实现了线程的同步机制


同步:A线程要请求某个资源,但是此资源正在被B线程使用中,因为同步机制存在,A线程请求

      不到,怎么办,A线程只能等待下去

异步:A线程要请求某个资源,但是此资源正在被B线程使用中,因为没有同步机制存在,A线程

      仍然请求的到,A线程无需等待


显然,同步最最安全,最保险的。而异步不安全,容易导致死锁,这样一个线程死掉就会导致整个

进程崩溃,但没有同步机制的存在,性能会有所提升


java中实现多线程

1)继承Thread,重写里面的run方法

2)实现runnable接口

 

举个例子:普通B/S模式(同步)AJAX技术(异步)

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

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

可见,彼“同步”非此“同步”——我们说的java中的那个共享数据同步(synchronized)

一个同步的对象是指行为(动作),一个是同步的对象是指物质(共享数据)。


一、关键字:

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

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

volatile(易变的)、atomic(原子的)、share(共享)

二、概念

1.

要跨线程维护正确的可见性,只要在几个线程之间分享非 final 变量,就必须使用 synchronized(或 volatile)

以确保一个线程可以看见另一个线程做的更改。

2、

为了在线程之间进行可靠的通信,也为了互斥访问,同步是必须的。这归因于java语言规范的内存模型,它规定了:

一个线程所做的变化何时以及如何变成对其它线程可见。

3.

多线程将异步行为引进程序,所以在需要同步时,必须有一种方法强制进行。例如:如果2个线程想要通信并且要

共享一个复杂的数据结构,如链表,此时需要确保它们互不冲突,也就是必须阻止B线程在A线程读数据的过程中

向链表里面写数据(A获得了锁,B必须等A释放了该锁)

4.同步

java在一个旧的的进程同步模型——监控器(Monitor)的基础上实现了一个巧妙的方案:监控器是一个控制机制,

可以认为是一个很小的、只能容纳一个线程的盒子,一旦一个线程进入监控器,其它的线程必须等待,直到那个

线程退出监控为止。通过这种方式,一个监控器可以保证共享资源在同一时刻只可被一个线程使用。这种方式称

之为同步。(一旦一个线程进入一个实例的任何同步方法,别的线程将不能进入该同一实例的其它同步方法,

但是该实例的非同步方法仍然能够被调用)。

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


6.锁提供了两种主要特性:互斥(mutual exclusion) 和可见性(visibility)

 

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

,这样,一次就只有一个线程能够使用该共享数据。


可见性要更加复杂一些,它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个

线程是可见的 —— 如果没有同步机制提供的这种可见性保证,线程看到的共享变量可能是修改前

的值或不一致的值,这将引发许多严重问题


小结:为了防止多个线程并发对同一数据的修改,所以需要同步,否则会造成数据不一致(就是所

谓的:线程安全。如java集合框架中Hashtable和Vector是线程安全的。我们的大部分程序都不是线

程安全的,因为没有进行同步,而且我们没有必要,因为大部分情况根本没有多线程环境)


7. 不要搞混了:同步、异步


举个例子:普通B/S模式(同步)AJAX技术(异步)同步:提交请求->等待服务器处理->处理完返回 这个期间客户端浏览器不能干任何事

异步:请求通过事件触发->服务器处理(这是浏览器仍然可以作其他事情)->处理完毕可见,彼“同步”非此“同步”

——我们说的java中的那个共享数据同步(synchronized)

一个同步的对象是指行为(动作),一个是同步的对象是指物质(共享数据)。

8、

 Java同步机制有4种实现方式:(部分引用网上资源)

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

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


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 变量提供理

想的线程安全,必须同时满足下面两个条件:

对变量的写操作不依赖于当前值;该变量没有包含在具有其他变量的不变式中。

 

  sleep() vs wait()
    sleep是线程类(Thread)的方法,导致此线程暂停执行指定时间,把执行机会给其他线程,但是监

控状态依然保持,到时后会自动恢复。调用sleep不会释放对象锁。
    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();

}

}

}

 

 

 

 

 

 

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

// TODO Auto-generated method stub

//target.nonsynCall(msg);

target.synCall(msg);

target.test();

}

 

}



参考自:http://blog.sina.com.cn/s/blog_6af29f290100s7qj.html