为您推荐:
精华内容
最热下载
问答
  • 4星
    679B cuihao1995 2021-03-27 18:05:19
  • 5星
    15.9MB Yao__Shun__Yu 2021-01-26 09:52:27
  • 5星
    85MB qq_41934573 2021-06-10 23:00:19
  • 5星
    50.68MB xipengbozai 2021-05-25 21:11:57
  • 当使用多线程访问同一个资源的时候,非常容易出现线程安全的问题(例如,当多个线程同时对一个数据进行修改的时候,会导致某些线程对数据的修改丢失)。 因此,需要采用同步机制来解决这种问题。而Java主要提供了三...

    当使用多线程访问同一个资源的时候,非常容易出现线程安全的问题(例如,当多个线程同时对一个数据进行修改的时候,会导致某些线程对数据的修改丢失)。

    因此,需要采用同步机制来解决这种问题。而Java主要提供了三种实现同步机制的方法。今天我们就来认识一下~~

    一、synchronized关键字

    在Java语言中,每个对象都有一个对象锁与之相关联,该锁表明对象在任何时候只允许被一个线程锁拥有,当一个线程调用对象的一段synchronized代码时,需要先获取这个锁,然后去执行相应的代码,执行结束之后,释放锁。

    而synchronized关键字主要有两种用法:synchronized方法synchronized块。此外,这个关键字还可以作用于静态方法、类或者某个实例,但这都对程序的效率有很大的影响

    1.synchronized方法。在方法的声明前主要有synchronized关键字,示例如下:

    public synchronized void mutiThreadAccess();

    只要把多个线程对类需要被同步的资源的操作放到mutiThreadAccess()方法中,就能保证这个方法在同一时刻只能被同一个线程访问,从而保证了多线程访问的安全性。然而,当一个方法的方法体规模非常大时,把该方法声明为synchronized会大大影响程序的执行效率。为了提高程序的效率,Java提供了synchronized块。

    2.synchronized块

    synchronized块既可以把任意的代码段声明为synchronized,也可以指定上锁的对象,有非常高的灵活性。其用法如下:

    synchronized(syncObject){
    
    //访问synchObject的代码
    
    }

    二、wait()方法与notify()方法

    当使用synchronized来修饰某个共享资源时,如果线程A1在执行synchronized代码,另一个线程A2也要同时执行同一个对象的同一synchronized代码时,线程A2将要等到线程A1执行完成之后,才能继续执行。在这种情况下可以使用wait()方法和notify()方法。

    在synchronized代码被执行期间,线程可以调用对象的wait()方法,释放对象锁,进入等待状态,并且可以调用notify()方法或者notifyAll()方法通知正在等待的其他线程。notify()方法仅唤醒一个线程(即等待队列中的第一个线程),并允许它去获得锁,notifyAll()方法唤醒所有等待这个对象的线程并允许他们去获得锁,但并不是让所有唤醒线程都去获取到锁,而是让他们去竞争。

    三、Lock

    JDK5新增加了Lock接口以及它的一个实现类ReentrantLock(重入锁),Lock也可以用来实现多线程的同步。具体而言,它提供了如下一些方法来实现多线程的同步:

    1.lock()。

    这个方法以阻塞的方式获取锁,也就是说,如果获取到锁了,立即返回;如果别的线程持有锁,当前线程就等待,知道获取到锁之后返回。

    2.tryLock()。

    这个方法与lock()方法不同,它以非阻塞的方式来获取锁。此外,它只是常识性地去获取一下锁,如果获取到了锁,立即返回true,否则立即返回false。

    3.tryLock(long timeout,TimeUnit unit)

    如果获取到锁,立即返回true,否则会等待参数给定的时间单元,在等待的过程中,如果获取到了锁,就返回true,如果等待超时则返回false。

    4.lockInterruptibly()

    如果获取了锁,立即返回;如果没有获取到锁,当前线程处于休眠状态,直到获取到锁,或者当前线程被别的线程中断(会受到InterruptedException异常)。它与lock()方法最大的区别在于如果lock()方法获取不到锁就会一直处于阻塞状态,而且还会忽略interrupt()方法。

    示例如下:

    package javatest;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class LockTest {
    
    	public static void main(String[] args)throws InterruptedException {
    		// TODO Auto-generated method stub
    		final Lock lock=new ReentrantLock();
    		lock.lock();
    		Thread t1=new Thread(new Runnable() {
    			public void run() {
    				try {
    					lock.lockInterruptibly();
    				}catch(InterruptedException e)
    				{
    					System.out.println("interrupted");
    				}
    			}
    		});
    		t1.start();
    		t1.interrupt();
    		Thread.sleep(1);
    	}
    }
    

    运行结果如下: 

    如果把lock.lockInterruptibly()替换为lock.lock(),编译器将会提示lock.lock()catch代码块无效,这是因为lock.lock()不会抛出异常,由此可见lock()方法会忽略interrupt()引发的异常。

     

    好啦,以上就是实现Java多线程同步的三种方法的相关总结,如果大家有什么更具体的发现或者发现文中有描述错误的地方,欢迎留言评论,我们一起学习呀~~

     

    Biu~~~~~~~~~~~~~~~~~~~~宫å´éªé¾ç«è¡¨æå|é¾ç«gifå¾è¡¨æåä¸è½½å¾ç~~~~~~~~~~~~~~~~~~~~~~pia!

    展开全文
    Searchin_R 2018-12-01 23:56:31
  • JAVA中线程同步的方法(7种)汇总 同步的方法: 一、同步方法  即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁,当用此关键字修饰方法时, 内置锁会保护整个方法。在调用该方法前...

    JAVA中线程同步的方法(7种)汇总

    同步的方法:

    一、同步方法

      即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁,当用此关键字修饰方法时, 内置锁会保护整个方法。在调用该方法前,需要获得内置锁,否则就处于阻塞状态。
    注: synchronized关键字也可以修饰静态方法,此时如果调用该静态方法,将会锁住整个类。

     

    二、同步代码块

      即有synchronized关键字修饰的语句块。 被该关键字修饰的语句块会自动被加上内置锁,从而实现同步
        代码如: 
    synchronized(object){ 
    }

        注:同步是一种高开销的操作,因此应该尽量减少同步的内容。通常没有必要同步整个方法,使用synchronized代码块同步关键代码即可。 
    复制代码
    复制代码
        package com.xhj.thread;
    
        /**
         * 线程同步的运用
         * 
         * @author XIEHEJUN
         * 
         */
        public class SynchronizedThread {
    
            class Bank {
                private int account = 100;
                public int getAccount() {
                    return account;
                }
    
                /**
                 * 用同步方法实现
                 * 
                 * @param money
                 */
                public synchronized void save(int money) {
                    account += money;
                }
    
                /**
                 * 用同步代码块实现
                 * 
                 * @param money
                 */
                public void save1(int money) {
                    synchronized (this) {
                        account += money;
                    }
                }
            }
    复制代码
    复制代码
    复制代码
    复制代码
    class NewThread implements Runnable {
                private Bank bank;
    
                public NewThread(Bank bank) {
                    this.bank = bank;
                }
    
                @Override
                public void run() {
                    for (int i = 0; i < 10; i++) {
                        // bank.save1(10);
                        bank.save(10);
                        System.out.println(i + "账户余额为:" + bank.getAccount());
                    }
                }
    
            }
    
            /**
             * 建立线程,调用内部类
             */
            public void useThread() {
                Bank bank = new Bank();
                NewThread new_thread = new NewThread(bank);
                System.out.println("线程1");
                Thread thread1 = new Thread(new_thread);
                thread1.start();
                System.out.println("线程2");
                Thread thread2 = new Thread(new_thread);
                thread2.start();
            }
    
            public static void main(String[] args) {
                SynchronizedThread st = new SynchronizedThread();
                st.useThread();
            }
    
        }
    复制代码
    复制代码

     

     
            
    =====================================

    示例加讲解

    同步是多线程中的重要概念。同步的使用可以保证在多线程运行的环境中,程序不会产生设计之外的错误结果。同步的实现方式有两种,同步方法和同步块,这两种方式都要用到synchronized关键字。

    同步方法:给一个方法增加synchronized修饰符之后就可以使它成为同步方法,这个方法可以是静态方法和非静态方法,但是不能是抽象类的抽象方法,也不能是接口中的接口方法。下面代码是一个同步方法的示例:

    复制代码
    复制代码
    public synchronized void aMethod() { 
        // do something 
    } 
    
    public static synchronized void anotherMethod() { 
        // do something 
    } 
    复制代码
    复制代码

    线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时,这个对象的所有同步方法都被锁定了,在此期间,其他任何线程都不能访问这个对象的任意一个同步方法,直到这个线程执行完它所调用的同步方法并从中退出,从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后,其他线程是可以访问这个对象的所有非同步方法的。

    同步块:同步块是通过锁定一个指定的对象,来对同步块中包含的代码进行同步;而同步方法是对这个方法块里的代码进行同步,而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法呢?那么线程锁定的就不是这个类的对象了,也不是这个类自身,而是这个类对应的java.lang.Class类型的对象。同步方法和同步块之间的相互制约只限于同一个对象之间,所以静态同步方法只受它所属类的其它静态同步方法的制约,而跟这个类的实例(对象)没有关系。

    如果一个对象既有同步方法,又有同步块,那么当其中任意一个同步方法或者同步块被某个线程执行时,这个对象就被锁定了,其他线程无法在此时访问这个对象的同步方法,也不能执行同步块。

    synchronized 关键字用于保护共享数据。请大家注意“共享数据”,你一定要分清哪些数据是共享数据,请看下面的例子:

    复制代码
    复制代码
    public class ThreadTest implements Runnable{
    
    public synchronized void run(){
      for(int i=0;i<10;i++) {
        System.out.print(" " + i);
      }
    }
    
    public static void main(String[] args) {
      Runnable r1 = new ThreadTest(); //也可写成ThreadTest r1 = new ThreadTest();
      Runnable r2 = new ThreadTest();
      Thread t1 = new Thread(r1);
      Thread t2 = new Thread(r2);
      t1.start();
      t2.start();
    }}
    复制代码
    复制代码

     

    在这个程序中,run()虽然被加上了synchronized 关键字,但保护的不是共享数据。因为这个程序中的t1,t2 是两个对象(r1,r2)的线程。而不同的对象的数据是不同的,r1,r2 有各自的run()方法,所以输出结果无法预知。

    synchronized的目的是使同一个对象的多个线程,在某个时刻只有其中的一个线程可以访问这个对象的synchronized 数据。每个对象都有一个“锁标志”,当这个对象的一个线程访问这个对象的某个synchronized 数据时,这个对象的所有被synchronized 修饰的数据将被上锁(因为“锁标志”被当前线程拿走了),只有当前线程访问完它要访问的synchronized 数据时,当前线程才会释放“锁标志”,这样同一个对象的其它线程才有机会访问synchronized 数据。

    示例3:

    复制代码
    复制代码
    public class ThreadTest implements Runnable{
    
    public synchronized void run(){
      for(int i=0;i<10;i++){
        System.out.print(" " + i);
      }
    }
    
    public static void main(String[] args){
      Runnable r = new ThreadTest();
      Thread t1 = new Thread(r);
      Thread t2 = new Thread(r);
      t1.start();
      t2.start();
    }}
    复制代码
    复制代码

     

    如果你运行1000 次这个程序,它的输出结果也一定每次都是:0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9。因为这里的synchronized 保护的是共享数据。t1,t2 是同一个对象(r)的两个线程,当其中的一个线程(例如:t1)开始执行run()方法时,由于run()受synchronized保护,所以同一个对象的其他线程(t2)无法访问synchronized 方法(run 方法)。只有当t1执行完后t2 才有机会执行。

    示例4:

    复制代码
    复制代码
    public class ThreadTest implements Runnable{
    
    public void run(){
    
        synchronized(this){
        for(int i=0;i<10;i++){
            System.out.print(" " + i);
        }
    } 
    }
    
    public static void main(String[] args){
        Runnable r = new ThreadTest();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();
    }
    }    
    复制代码
    复制代码

     

    这个程序与示例3 的运行结果一样。在可能的情况下,应该把保护范围缩到最小,可以用示例4 的形式,this 代表“这个对象”。没有必要把整个run()保护起来,run()中的代码只有一个for循环,所以只要保护for 循环就可以了。

    示例5:

    复制代码
    复制代码
    public class ThreadTest implements Runnable{
    
    public void run(){
      for(int k=0;k<5;k++){
        System.out.println(Thread.currentThread().getName()+ " : for loop : " + k);
      }
    
    synchronized(this){
      for(int k=0;k<5;k++) {
        System.out.println(Thread.currentThread().getName()+ " : synchronized for loop : " + k);
      }} }
    
    public static void main(String[] args){
      Runnable r = new ThreadTest();
      Thread t1 = new Thread(r,"t1_name");
      Thread t2 = new Thread(r,"t2_name");
      t1.start();
      t2.start();
    } }
    复制代码
    复制代码

     

    运行结果:

    t1_name : for loop : 0

    t1_name : for loop : 1

    t1_name : for loop : 2

    t2_name : for loop : 0

    t1_name : for loop : 3

    t2_name : for loop : 1

    t1_name : for loop : 4

    t2_name : for loop : 2

    t1_name : synchronized for loop : 0

    t2_name : for loop : 3

    t1_name : synchronized for loop : 1

    t2_name : for loop : 4

    t1_name : synchronized for loop : 2

    t1_name : synchronized for loop : 3

    t1_name : synchronized for loop : 4

    t2_name : synchronized for loop : 0

    t2_name : synchronized for loop : 1

    t2_name : synchronized for loop : 2

    t2_name : synchronized for loop : 3

    t2_name : synchronized for loop : 4

    第一个for 循环没有受synchronized 保护。对于第一个for 循环,t1,t2 可以同时访问。运行结果表明t1 执行到了k=2 时,t2 开始执行了。t1 首先执行完了第一个for 循环,此时t2还没有执行完第一个for 循环(t2 刚执行到k=2)。t1 开始执行第二个for 循环,当t1的第二个for 循环执行到k=1 时,t2 的第一个for 循环执行完了。t2 想开始执行第二个for 循环,但由于t1 首先执行了第二个for 循环,这个对象的锁标志自然在t1 手中(synchronized 方法的执行权也就落到了t1 手中),在t1 没执行完第二个for 循环的时候,它是不会释放锁标志的。所以t2 必须等到t1 执行完第二个for 循环后,它才可以执行第二个for 循环。

    =====================================

    三、wait与notify

    wait():使一个线程处于等待状态,并且释放所持有的对象的lock。

    sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用此方法要捕捉InterruptedException异常。
    notify():唤醒一个处于等待状态的线程,注意的是在调用此方法的时候,并不能确切的唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且不是按优先级。
    Allnotity():唤醒所有处入等待状态的线程,注意并不是给所有唤醒线程一个对象的锁,而是让它们竞争。

    详细见:wait、notify、notifyAll的使用方法

    四、使用特殊域变量(volatile)实现线程同步

        a.volatile关键字为域变量的访问提供了一种免锁机制
        b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新
        c.因此每次使用该域就要重新计算,而不是使用寄存器中的值 
        d.volatile不会提供任何原子操作,它也不能用来修饰final类型的变量 
        
        例如: 
            在上面的例子当中,只需在account前面加上volatile修饰,即可实现线程同步。 
        
        代码实例: 
     
    复制代码
    复制代码
            //只给出要修改的代码,其余代码与上同
            class Bank {
                //需要同步的变量加上volatile
                private volatile int account = 100;
    
                public int getAccount() {
                    return account;
                }
                //这里不再需要synchronized 
                public void save(int money) {
                    account += money;
                }
            }
    复制代码
    复制代码
        注:多线程中的非同步问题主要出现在对域的读写上,如果让域自身避免这个问题,则就不需要修改操作该域的方法。 
        用final域,有锁保护的域和volatile域可以避免非同步的问题。 

    五、使用重入锁实现线程同步

        在 JavaSE5.0中新增了一个java.util.concurrent包来支持同步。 
        ReentrantLock类是可重入、互斥、实现了Lock接口的锁,它与使用synchronized方法和快具有相同的基本行为和语义,并且扩展了其能力。
     ReenreantLock类的常用方法有:
    ReentrantLock() : 创建一个ReentrantLock实例 
    lock() : 获得锁 
    unlock() : 释放锁 

    注:ReentrantLock()还有一个可以创建公平锁的构造方法,但由于能大幅度降低程序运行效率,不推荐使用 
            
        例如: 
            在上面例子的基础上,改写后的代码为: 
    复制代码
    复制代码
           //只给出要修改的代码,其余代码与上同
            class Bank {
    
                private int account = 100;
                //需要声明这个锁
                private Lock lock = new ReentrantLock();
                public int getAccount() {
                    return account;
                }
                //这里不再需要synchronized 
                public void save(int money) {
                    lock.lock();
                    try{
                        account += money;
                    }finally{
                        lock.unlock();
                    }
    
                }
            }
    复制代码
    复制代码
         注:关于Lock对象和synchronized关键字的选择: 
            a.最好两个都不用,使用一种java.util.concurrent包提供的机制,能够帮助用户处理所有与锁相关的代码。 
            b.如果synchronized关键字能满足用户的需求,就用synchronized,因为它能简化代码 
            c.如果需要更高级的功能,就用ReentrantLock类,此时要注意及时释放锁,否则会出现死锁,通常在finally代码释放锁 
     

    六、使用局部变量实现线程同步

        如果使用ThreadLocal管理变量,则每一个使用该变量的线程都获得该变量的副本,副本之间相互独立,这样每一个线程都可以随意修改自己的变量副本,而不会对其他线程产生影响。
         ThreadLocal 类的常用方法
    ThreadLocal() : 创建一个线程本地变量 
    get() : 返回此线程局部变量的当前线程副本中的值 
    initialValue() : 返回此线程局部变量的当前线程的"初始值" 
    set(T value) : 将此线程局部变量的当前线程副本中的值设置为value

        例如: 
            在上面例子基础上,修改后的代码为: 
    复制代码
    复制代码
            //只改Bank类,其余代码与上同
            public class Bank{
                //使用ThreadLocal类管理共享变量account
                private static ThreadLocal<Integer> account = new ThreadLocal<Integer>(){
                    @Override
                    protected Integer initialValue(){
                        return 100;
                    }
                };
                public void save(int money){
                    account.set(account.get()+money);
                }
                public int getAccount(){
                    return account.get();
                }
            }
    复制代码
    复制代码
        注:ThreadLocal与同步机制 
            a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题。 
            b.前者采用以”空间换时间”的方法,后者采用以”时间换空间”的方式
     

    七、使用阻塞队列实现线程同步

    前面5种同步方式都是在底层实现的线程同步,但是我们在实际开发当中,应当尽量远离底层结构。 使用javaSE5.0版本中新增的java.util.concurrent包将有助于简化开发。 本小节主要是使用LinkedBlockingQueue<E>来实现线程的同步 LinkedBlockingQueue<E>是一个基于已连接节点的,范围任意的blocking queue。 队列是先进先出的顺序(FIFO),关于队列以后会详细讲解~LinkedBlockingQueue 类常用方法 LinkedBlockingQueue() : 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue put(E e) : 在队尾添加一个元素,如果队列满则阻塞 size() : 返回队列中的元素个数 take() : 移除并返回队头元素,如果队列空则阻塞代码实例: 实现商家生产商品和买卖商品的同步

     

    注:BlockingQueue<E>定义了阻塞队列的常用方法,尤其是三种添加元素的方法,我们要多加注意,当队列满时:

      add()方法会抛出异常

      offer()方法返回false

      put()方法会阻塞

     

     

    7.使用原子变量实现线程同步

     

    需要使用线程同步的根本原因在于对普通变量的操作不是原子的。

    那么什么是原子操作呢?原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作即-这几种行为要么同时完成,要么都不完成。在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类,使用该类可以简化线程同步。其中AtomicInteger 表可以用原子方式更新int的值,可用在应用程序中(如以原子方式增加的计数器),但不能用于替换Integer;可扩展Number,允许那些处理机遇数字类的工具和实用工具进行统一访问。

    AtomicInteger类常用方法:

    AtomicInteger(int initialValue) : 创建具有给定初始值的新的

    AtomicIntegeraddAddGet(int dalta) : 以原子方式将给定值与当前值相加

    get() : 获取当前值

    代码实例:

    只改Bank类,其余代码与上面第一个例子同

    复制代码
    复制代码
    class Bank {
        private AtomicInteger account = new AtomicInteger(100);
        public AtomicInteger getAccount() {
            return account; 
        } 
        public void save(int money) {
            account.addAndGet(money);
        }
    }
    复制代码
    复制代码

    补充–原子操作主要有:  

    对于引用变量和大多数原始变量(long和double除外)的读写操作;  

    对于所有使用volatile修饰的变量(包括long和double)的读写操作。


    分类: JAVA
    0
    0

    « 上一篇: Java中ArrayList和LinkedList区别
    » 下一篇: JSP取得绝对路径
    展开全文
    haorenwanglu 2017-11-15 19:43:55
  • 线程安全问题一般是发生再多线程环境,当多个线程同时共享一个全局变量或静态变量做写的操作时候,可能会发生数据冲突问题,也就是线程安全问题,在读的操作不会发生数据冲突问题 下面看个简单的买票例子 案例:需求...

    一、为什么会有线程安全问题?

    线程安全问题一般是发生再多线程环境,当多个线程同时共享一个全局变量或静态变量做写的操作时候,可能会发生数据冲突问题,也就是线程安全问题,在读的操作不会发生数据冲突问题 下面看个简单的买票例子 案例:需求现在有100张火车票,有两个窗口同时抢火车票,请使用多线程模拟抢票效果。 代码:

    public class ThreadTrain1 implements Runnable { private int count = 100;
    
    @Override
    public void run() {
    	while (count > 0) {
    		try {
    			Thread.sleep(50);
    		} catch (Exception e) {
    			// TODO: handle exception
    		}
    		sale();
    	}
    }
    
    public void sale() {
    
    		System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
    		count--;
    	 }
    }
    
    
    }
    
    public class ThreadDemo { public static void main(String[] args) { ThreadTrain1 threadTrain1 = new ThreadTrain1(); Thread t1 = new Thread(threadTrain1, "①号窗口"); Thread t2 = new Thread(threadTrain1, "②号窗口"); t1.start(); t2.start(); } } 运行结果
    

    在这里插入图片描述

    我们可以发现一号窗口和二号窗口会卖出重复或者超卖现象,这就是在多线程环境下共享资源造成的线程安全问题

    (想自学习编程的小伙伴请搜索圈T社区,更多行业相关资讯更有行业相关免费视频教程。完全免费哦!)

    二、如何解决线程安全问题

    Synchronized(/'sɪŋkrənaɪzd/) ------相当于自动挡 Lock(/lɒk/ )—jdk1.5并发包才又 ------相当于手动挡

    1. 如何解决多线程之间线程安全问题? 答:使用多线程之间同步synchronized或使用锁(lock)。
    2. 为什么使用线程同步或使用锁能解决线程安全问题呢? 答:将可能会发生数据冲突问题(线程不安全问题),只能让当前一个线程进行执行。代码执行完成后释放锁,让后才能让其他线程进行执行。这样的话就可以解决线程不安全问题。
    3. 什么是多线程之间同步? 答:当多个线程共享同一个资源,不会受到其他线程的干扰。
    4. 什么地方需要考虑枷锁? 答:真正产生共享同一个全局变量的时候。
    5. 锁是在什么时候释放的? 答:代码执行完毕或者是程序抛出异常,都会把锁释放掉

    三、同步

    3.1、什么是同步代码块? 答:就是将可能会发生线程安全问题的代码,给包括起来。 synchronized(同一个数据){ 可能会发生线程冲突问题 } 就是同步代码块 synchronized(对象) { //这个对象可以为任意对象 需要被同步的代码 } 对象如同锁,持有锁的线程可以在同步中执行 没持有锁的线程即使获取CPU的执行权,也进不去 同步的前提:

    1. 必须要有两个或者两个以上的线程
    2. 必须是多个线程使用同一个锁 必须保证同步中只能有一个线程在运行 好处:解决了多线程的安全问题 弊端:多个线程需要判断锁,较为消耗资源、抢锁的资源。 原理:有一个线程已经拿到了锁,其他线程已经有了cpu执行权,一直排队等待其他线程释放锁。 代码样例: private static Object oj = new Object(); public void sale() { // 前提 多线程进行使用、多个线程只能拿到一把锁。 // 保证只能让一个线程 在执行 缺点效率降低 synchronized (oj) { if (count > 0) { System.out.println(Thread.currentThread().getName() + “,出售第” + (100 - count + 1) + “票”); count–; } } } 4、同步函数 4.1、什么是同步函数? 答:在方法上修饰synchronized 称为同步函数 代码样例: public synchronized void sale() { if (trainCount > 0) { try { Thread.sleep(40); } catch (Exception e) { } System.out.println(Thread.currentThread().getName() + “,出售 第” + (100 - trainCount + 1) + “张票.”); trainCount–; } } 同学们思考问题?同步函数用的是什么锁? 答:同步函数使用this锁。 证明方式: 一个线程使用同步代码块(this明锁),另一个线程使用同步函数。如果两个线程抢票不能实现同步,那么会出现数据错误。 代码:
    package com.itmayiedu;
    class ThreadTrain2 implements Runnable { private int count = 100; public boolean flag = true; private static Object oj = new Object();
    
    @Override
    public void run() {
    	if (flag) {
    
    		while (count > 0) {
    
    			synchronized (this) {
    				if (count > 0) {
    					try {
    						Thread.sleep(50);
    					} catch (Exception e) {
    						// TODO: handle exception
    					}
    					System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
    					count--;
    				}
    			}
    
    		}
    
    	} else {
    		while (count > 0) {
    			sale();
    		}
    	}
    
    }
    
    public synchronized void sale() {
    	// 前提 多线程进行使用、多个线程只能拿到一把锁。
    	// 保证只能让一个线程 在执行 缺点效率降低
    	// synchronized (oj) {
    	if (count > 0) {
    		try {
    			Thread.sleep(50);
    		} catch (Exception e) {
    			// TODO: handle exception
    		}
    		System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
    		count--;
    	}
    	// }
    }
    
    }
    
    public class ThreadDemo2 { public static void main(String[] args) throws InterruptedException { ThreadTrain2 threadTrain1 = new ThreadTrain2(); Thread t1 = new Thread(threadTrain1, "①号窗口"); Thread t2 = new Thread(threadTrain1, "②号窗口"); t1.start(); Thread.sleep(40); threadTrain1.flag = false; t2.start(); } } 
    

    5、静态同步函数 5.1、什么是静态同步函数?

    1. 方法上加上static(/'stætɪk/)关键字,使用synchronized 关键字修饰 或者使用类.class文件。
    2. 静态的同步函数使用的锁是 该函数所属字节码文件对象
    3. 可以用 getClass方法获取,也可以用当前 类名.class 表示。 代码: synchronized (ThreadTrain.class) { System.out.println(Thread.currentThread().getName() + “,出售 第” + (100 - trainCount + 1) + “张票.”); trainCount–; try { Thread.sleep(100); } catch (Exception e) { } } 总结: synchronized 修饰方法使用锁是当前this锁。 synchronized 修饰静态方法使用锁是当前类的字节码文件 。 多线程死锁 3.1、什么是多线程死锁 答:同步中嵌套同步,导致锁无法释放 代码:
     package com.itmayiedu;
    class ThreadTrain6 implements Runnable { // 这是货票总票数,多个线程会同时共享资源 private int trainCount = 100; public boolean flag = true; private Object mutex = new Object();
    
    @Override
    public void run() {
    	if (flag) {
    		while (true) {
    			synchronized (mutex) {
    				// 锁(同步代码块)在什么时候释放? 代码执行完, 自动释放锁.
    				// 如果flag为true 先拿到 obj锁,在拿到this 锁、 才能执行。
    				// 如果flag为false先拿到this,在拿到obj锁,才能执行。
    				// 死锁解决办法:不要在同步中嵌套同步。
    				sale();
    			}
    		}
    	} else {
    		while (true) {
    			sale();
    		}
    	}
    }
    
    /**
     * 
     * @methodDesc: 功能描述:(出售火车票)
     */
    public synchronized void sale() {
    	synchronized (mutex) {
    		if (trainCount > 0) {
    			try {
    				Thread.sleep(40);
    			} catch (Exception e) {
    
    			}
    			System.out.println(Thread.currentThread().getName() + ",出售 第" + (100 - trainCount + 1) + "张票.");
    			trainCount--;
    		}
    	}
    }
    
    }
    
    public class DeadlockThread {
    
    public static void main(String[] args) throws InterruptedException {
    
    	ThreadTrain6 threadTrain = new ThreadTrain6(); // 定义 一个实例
    	Thread thread1 = new Thread(threadTrain, "一号窗口");
    	Thread thread2 = new Thread(threadTrain, "二号窗口");
    	thread1.start();
    	Thread.sleep(40);
    	threadTrain.flag = false;
    	thread2.start();
    }
    
    }
    

    4、多线程有三大特性

    1. 原子性 一个操作或者多个操作要么全部执行要么就都不执行。
    2. 可见性 私有内存修改能及时同步到主内存,保证私有和主的可见一致性
    3. 有序性 程序执行的顺序按照代码的先后顺序执行。
      4.1、什么是原子性 即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断,要么就都不执行。 一个很经典的例子就是银行账户转账问题: 比如从账户A向账户B转1000元,那么必然包括2个操作:从账户A减去1000元,往账户B加上1000元。这2个操作必须要具备原子性才能保证不出现一些意外的问题。 我们操作数据也是如此,比如i = i+1;其中就包括,读取i的值,计算i,写入i。这行代码在Java中是不具备原子性的,则多线程运行肯定会出问题,所以也需要我们使用同步和lock这些东西来确保这个特性了。 原子性其实就是保证数据一致、线程安全一部分,

    4.2、什么是可见性 当多个线程访问同一个变量时,一个线程修改了这个变量的值,其他线程能够立即看得到修改的值。 若两个线程在不同的cpu,那么线程1改变了i的值还没刷新到主存,线程2又使用了i,那么这个i值肯定还是之前的,线程1对变量的修改线程没看到这就是可见性问题。

    4.3、什么是有序性 程序执行的顺序按照代码的先后顺序执行。 一般来说处理器为了提高程序运行效率,可能会对输入代码进行优化,它不保证程序中各个语句的执行先后顺序同代码中的顺序一致,但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。如下: int a = 10; //语句1 int r = 2; //语句2 a = a + 3; //语句3 r = a*a; //语句4 则因为重排序,他还可能执行顺序为 2-1-3-4,1-3-2-4 但绝不可能 2-1-4-3,因为这打破了依赖关系。 显然重排序对单线程运行是不会有任何问题,而多线程就不一定了,所以我们在多线程编程时就得考虑这个问题了。

    五、java内存模型

    共享内存模型指的就是Java内存模型(简称JMM),JMM决定一个线程对共享变量的写入时,能对另一个线程可见。从抽象的角度来看,JMM定义了线程和主内存之间的抽象关系:线程之间的共享变量存储在主内存(main memory)中,每个线程都有一个私有的本地内存(local memory),本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念,并不真实存在。它涵盖了缓存,写缓冲区,寄存器以及其他的硬件和编译器优化。
    在这里插入图片描述

    从上图来看,线程A与线程B之间如要通信的话,必须要经历下面2个步骤:

    1. 首先,线程A把本地内存A中更新过的共享变量刷新到主内存中去。
    2. 然后,线程B到主内存中去读取线程A之前已更新过的共享变量。 下面通过示意图来说明这两个步骤:
      在这里插入图片描述
      如上图所示,本地内存A和B有主内存中共享变量x的副本。假设初始时,这三个内存中的x值都为0。线程A在执行时,把更新后的x值(假设值为1)临时存放在自己的本地内存A中。当线程A和线程B需要通信时,线程A首先会把自己本地内存中修改后的x值刷新到主内存中,此时主内存中的x值变为了1。随后,线程B到主内存中去读取线程A更新后的x值,此时线程B的本地内存的x值也变为了1。 从整体来看,这两个步骤实质上是线程A在向线程B发送消息,而且这个通信过程必须要经过主内存。JMM通过控制主内存与每个线程的本地内存之间的交互,来为java程序员提供内存可见性保证。 总结:什么是Java内存模型:java内存模型简称jmm,定义了一个线程对另一个线程可见。共享变量存放在主内存中,每个线程都有自己的本地内存,当多个线程同时访问一个数据的时候,可能本地内存没有及时刷新到主内存,所以就会发生线程安全问题。

    六、volatile实现线程可见性

    Volatile 关键字的作用是变量在多个线程之间可见,但不保证原子性,下面的文章链接讲的非常好,这里不详细说了 juejin.im/post/5afd22…

    六、AtomicInteger原子类

    AtomicInteger是一个提供原子操作的Integer类,通过线程安全的方式操作加减。下面是个例子可以运行对比下count和atomicInteger的结果会发现无论运行多少次,atomicInteger的结果都是正确的 package com;

    import java.util.concurrent.atomic.AtomicInteger;
    
    public class VolatileNoAtomic extends Thread { static int count = 0; private static AtomicInteger atomicInteger = new AtomicInteger(0);
    
    @Override
    public  void  run() {
    	for (int i = 0; i < 1000; i++) {
    		//等同于i++
    		atomicInteger.incrementAndGet();
    		count++;
    	}
    	System.out.println(atomicInteger+","+count);
    }
    
    public static void main(String[] args) {
    	// 初始化10个线程
    	VolatileNoAtomic[] volatileNoAtomic = new VolatileNoAtomic[10];
    	for (int i = 0; i < 10; i++) {
    		// 创建
    		volatileNoAtomic[i] = new VolatileNoAtomic();
    	}
    	for (int i = 0; i < volatileNoAtomic.length; i++) {
    		volatileNoAtomic[i].start();
    	}
    	} 
    }
    

    上面只是简单的一个原子类的介绍

    七、volatile(/'vɒlətaɪl/)与synchronized(/'sɪŋkrənaɪzd/)区别

    仅靠volatile不能保证线程的安全性。(原子性) ①volatile轻量级,只能修饰变量。synchronized重量级,还可修饰方法 ②volatile只能保证数据的可见性,不能用来同步,因为多个线程并发访问volatile修饰的变量不会阻塞。 synchronized不仅保证可见性,而且还保证原子性,因为,只有获得了锁的线程才能进入临界区,从而保证临界区中的所有语句都全部执行。多个线程争抢synchronized锁对象时,会出现阻塞。 线程安全性 线程安全性包括两个方面,①可见性。②原子性。 从上面自增的例子中可以看出:仅仅使用volatile并不能保证线程安全性。而synchronized则可实现线程的安全性。 八、ThreadLocal深度解析

    展开全文
    wanghao112956 2019-07-01 11:56:53
  • 5星
    38KB sprintfwater 2013-04-18 13:19:41
  • 二、为什么要线程同步因为当我们有个线程要同时访问一个变量或对象时,如果这些线程中既有读又有写操作时,就会导致变量值或对象的状态出现混乱,从而导致程序异常。举个例子,如果一个银行账户同时被两个线程操作...

    一、引言

    前几天面试,被大师虐残了,好多基础知识必须得重新拿起来啊。闲话不多说,进入正题。

    二、为什么要线程同步

    因为当我们有多个线程要同时访问一个变量或对象时,如果这些线程中既有读又有写操作时,就会导致变量值或对象的状态出现混乱,从而导致程序异常。举个例子,如果一个银行账户同时被两个线程操作,一个取100块,一个存钱100块。假设账户原本有0块,如果取钱线程和存钱线程同时发生,会出现什么结果呢?取钱不成功,账户余额是100.取钱成功了,账户余额是0.那到底是哪个呢?很难说清楚。因此多线程同步就是要解决这个问题。

    三、不同步时的代码

    Bank.java

    [java]  view plain  copy
    1. package threadTest;  
    2.   
    3. /** 
    4.  * @author ww 
    5.  * 
    6.  */  
    7. public class Bank {  
    8.   
    9.     private int count =0;//账户余额  
    10.       
    11.     //存钱  
    12.     public  void addMoney(int money){  
    13.         count +=money;  
    14.         System.out.println(System.currentTimeMillis()+"存进:"+money);  
    15.     }  
    16.       
    17.     //取钱  
    18.     public  void subMoney(int money){  
    19.         if(count-money < 0){  
    20.             System.out.println("余额不足");  
    21.             return;  
    22.         }  
    23.         count -=money;  
    24.         System.out.println(+System.currentTimeMillis()+"取出:"+money);  
    25.     }  
    26.       
    27.     //查询  
    28.     public void lookMoney(){  
    29.         System.out.println("账户余额:"+count);  
    30.     }  
    31. }  


    SyncThreadTest.java

    [java]  view plain  copy
    1. package threadTest;  
    2.   
    3.   
    4. public class SyncThreadTest {  
    5.   
    6.     public static void main(String args[]){  
    7.         final Bank bank=new Bank();  
    8.           
    9.         Thread tadd=new Thread(new Runnable() {  
    10.               
    11.             @Override  
    12.             public void run() {  
    13.                 // TODO Auto-generated method stub  
    14.                 while(true){  
    15.                     try {  
    16.                         Thread.sleep(1000);  
    17.                     } catch (InterruptedException e) {  
    18.                         // TODO Auto-generated catch block  
    19.                         e.printStackTrace();  
    20.                     }  
    21.                     bank.addMoney(100);  
    22.                     bank.lookMoney();  
    23.                     System.out.println("\n");  
    24.                       
    25.                 }  
    26.             }  
    27.         });  
    28.           
    29.         Thread tsub = new Thread(new Runnable() {  
    30.               
    31.             @Override  
    32.             public void run() {  
    33.                 // TODO Auto-generated method stub  
    34.                 while(true){  
    35.                     bank.subMoney(100);  
    36.                     bank.lookMoney();  
    37.                     System.out.println("\n");  
    38.                     try {  
    39.                         Thread.sleep(1000);  
    40.                     } catch (InterruptedException e) {  
    41.                         // TODO Auto-generated catch block  
    42.                         e.printStackTrace();  
    43.                     }     
    44.                 }  
    45.             }  
    46.         });  
    47.         tsub.start();  
    48.           
    49.         tadd.start();  
    50.     }  
    51.       
    52.       
    53.   
    54. }  

    代码很简单,我就不解释了,看看运行结果怎样呢?截取了其中的一部分,是不是很乱,有写看不懂。

    [java]  view plain  copy
    1. 余额不足  
    2. 账户余额:0  
    3.   
    4.   
    5. 余额不足  
    6. 账户余额:100  
    7.   
    8.   
    9. 1441790503354存进:100  
    10. 账户余额:100  
    11.   
    12.   
    13. 1441790504354存进:100  
    14. 账户余额:100  
    15.   
    16.   
    17. 1441790504354取出:100  
    18. 账户余额:100  
    19.   
    20.   
    21. 1441790505355存进:100  
    22. 账户余额:100  
    23.   
    24.   
    25. 1441790505355取出:100  
    26. 账户余额:100  

    四、使用同步时的代码

    (1)同步方法:

    即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁,当用此关键字修饰方法时,内置锁会保护整个方法。在调用该方法前,需要获得内置锁,否则就处于阻塞状态。

    修改后的Bank.java

    [java]  view plain  copy
    1. package threadTest;  
    2.   
    3. /** 
    4.  * @author ww 
    5.  * 
    6.  */  
    7. public class Bank {  
    8.   
    9.     private int count =0;//账户余额  
    10.       
    11.     //存钱  
    12.     public  synchronized void addMoney(int money){  
    13.         count +=money;  
    14.         System.out.println(System.currentTimeMillis()+"存进:"+money);  
    15.     }  
    16.       
    17.     //取钱  
    18.     public  synchronized void subMoney(int money){  
    19.         if(count-money < 0){  
    20.             System.out.println("余额不足");  
    21.             return;  
    22.         }  
    23.         count -=money;  
    24.         System.out.println(+System.currentTimeMillis()+"取出:"+money);  
    25.     }  
    26.       
    27.     //查询  
    28.     public void lookMoney(){  
    29.         System.out.println("账户余额:"+count);  
    30.     }  
    31. }  
    再看看运行结果:

    [html]  view plain  copy
    1. 余额不足  
    2. 账户余额:0  
    3.   
    4.   
    5. 余额不足  
    6. 账户余额:0  
    7.   
    8.   
    9. 1441790837380存进:100  
    10. 账户余额:100  
    11.   
    12.   
    13. 1441790838380取出:100  
    14. 账户余额:0  
    15. 1441790838380存进:100  
    16. 账户余额:100  
    17.   
    18.   
    19.   
    20.   
    21. 1441790839381取出:100  
    22. 账户余额:0  
    瞬间感觉可以理解了吧。

    注: synchronized关键字也可以修饰静态方法,此时如果调用该静态方法,将会锁住整个类

    (2)同步代码块

    即有synchronized关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁,从而实现同步

    Bank.java代码如下:

    [java]  view plain  copy
    1. package threadTest;  
    2.   
    3. /** 
    4.  * @author ww 
    5.  * 
    6.  */  
    7. public class Bank {  
    8.   
    9.     private int count =0;//账户余额  
    10.       
    11.     //存钱  
    12.     public   void addMoney(int money){  
    13.           
    14.         synchronized (this) {  
    15.             count +=money;  
    16.         }  
    17.         System.out.println(System.currentTimeMillis()+"存进:"+money);  
    18.     }  
    19.       
    20.     //取钱  
    21.     public   void subMoney(int money){  
    22.           
    23.         synchronized (this) {  
    24.             if(count-money < 0){  
    25.                 System.out.println("余额不足");  
    26.                 return;  
    27.             }  
    28.             count -=money;  
    29.         }  
    30.         System.out.println(+System.currentTimeMillis()+"取出:"+money);  
    31.     }  
    32.       
    33.     //查询  
    34.     public void lookMoney(){  
    35.         System.out.println("账户余额:"+count);  
    36.     }  
    37. }  

    运行结果如下:

    [html]  view plain  copy
    1. 余额不足  
    2. 账户余额:0  
    3.   
    4.   
    5. 1441791806699存进:100  
    6. 账户余额:100  
    7.   
    8.   
    9. 1441791806700取出:100  
    10. 账户余额:0  
    11.   
    12.   
    13. 1441791807699存进:100  
    14. 账户余额:100  

    效果和方法一差不多。

    注:同步是一种高开销的操作,因此应该尽量减少同步的内容。通常没有必要同步整个方法,使用synchronized代码块同步关键代码即可。

    (3)使用特殊域变量(volatile)实现线程同步

        a.volatile关键字为域变量的访问提供了一种免锁机制 
        b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新 
        c.因此每次使用该域就要重新计算,而不是使用寄存器中的值 
        d.volatile不会提供任何原子操作,它也不能用来修饰final类型的变量

    Bank.java代码如下:

    [java]  view plain  copy
    1. package threadTest;  
    2.   
    3. /** 
    4.  * @author ww 
    5.  * 
    6.  */  
    7. public class Bank {  
    8.   
    9.     private volatile int count = 0;// 账户余额  
    10.   
    11.     // 存钱  
    12.     public void addMoney(int money) {  
    13.   
    14.         count += money;  
    15.         System.out.println(System.currentTimeMillis() + "存进:" + money);  
    16.     }  
    17.   
    18.     // 取钱  
    19.     public void subMoney(int money) {  
    20.   
    21.         if (count - money < 0) {  
    22.             System.out.println("余额不足");  
    23.             return;  
    24.         }  
    25.         count -= money;  
    26.         System.out.println(+System.currentTimeMillis() + "取出:" + money);  
    27.     }  
    28.   
    29.     // 查询  
    30.     public void lookMoney() {  
    31.         System.out.println("账户余额:" + count);  
    32.     }  
    33. }  
    运行效果怎样呢?

    [html]  view plain  copy
    1. 余额不足  
    2. 账户余额:0  
    3.   
    4.   
    5. 余额不足  
    6. 账户余额:100  
    7.   
    8.   
    9. 1441792010959存进:100  
    10. 账户余额:100  
    11.   
    12.   
    13. 1441792011960取出:100  
    14. 账户余额:0  
    15.   
    16.   
    17. 1441792011961存进:100  
    18. 账户余额:100  

    是不是又看不懂了,又乱了。这是为什么呢?就是因为volatile不能保证原子操作导致的,因此volatile不能代替synchronized。此外volatile会组织编译器对代码优化,因此能不使用它就不适用它吧。 它的原理是每次要线程要访问volatile修饰的变量时都是从内存中读取,而不是存缓存当中读取,因此每个线程访问到的变量值都是一样的。这样就保证了同步。

    (4)使用重入锁实现线程同步

        在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。ReentrantLock类是可重入、互斥、实现了Lock接口的锁, 它与使用synchronized方法和快具有相同的基本行为和语义,并且扩展了其能力。
         ReenreantLock类的常用方法有:
             ReentrantLock() : 创建一个ReentrantLock实例 
             lock() : 获得锁 
             unlock() : 释放锁 
        注:ReentrantLock()还有一个可以创建公平锁的构造方法,但由于能大幅度降低程序运行效率,不推荐使用 
    Bank.java代码修改如下:

    [java]  view plain  copy
    1. package threadTest;  
    2.   
    3. import java.util.concurrent.locks.Lock;  
    4. import java.util.concurrent.locks.ReentrantLock;  
    5.   
    6. /** 
    7.  * @author ww 
    8.  * 
    9.  */  
    10. public class Bank {  
    11.   
    12.     private  int count = 0;// 账户余额  
    13.       
    14.     //需要声明这个锁  
    15.     private Lock lock = new ReentrantLock();  
    16.   
    17.     // 存钱  
    18.     public void addMoney(int money) {  
    19.         lock.lock();//上锁  
    20.         try{  
    21.         count += money;  
    22.         System.out.println(System.currentTimeMillis() + "存进:" + money);  
    23.           
    24.         }finally{  
    25.             lock.unlock();//解锁  
    26.         }  
    27.     }  
    28.   
    29.     // 取钱  
    30.     public void subMoney(int money) {  
    31.         lock.lock();  
    32.         try{  
    33.               
    34.         if (count - money < 0) {  
    35.             System.out.println("余额不足");  
    36.             return;  
    37.         }  
    38.         count -= money;  
    39.         System.out.println(+System.currentTimeMillis() + "取出:" + money);  
    40.         }finally{  
    41.             lock.unlock();  
    42.         }  
    43.     }  
    44.   
    45.     // 查询  
    46.     public void lookMoney() {  
    47.         System.out.println("账户余额:" + count);  
    48.     }  
    49. }  
    运行效果怎么样呢?

    [html]  view plain  copy
    1. 余额不足  
    2. 账户余额:0  
    3.   
    4.   
    5. 余额不足  
    6. 账户余额:0  
    7.   
    8.   
    9. 1441792891934存进:100  
    10. 账户余额:100  
    11.   
    12.   
    13. 1441792892935存进:100  
    14. 账户余额:200  
    15.   
    16.   
    17. 1441792892954取出:100  
    18. 账户余额:100  
    效果和前两种方法差不多。

    如果synchronized关键字能满足用户的需求,就用synchronized,因为它能简化代码 。如果需要更高级的功能,就用ReentrantLock类,此时要注意及时释放锁,否则会出现死锁,通常在finally代码释放锁 

    (5)使用局部变量实现线程同步

    Bank.java代码如下:

    [java]  view plain  copy
    1. package threadTest;  
    2.   
    3.   
    4. /** 
    5.  * @author ww 
    6.  * 
    7.  */  
    8. public class Bank {  
    9.   
    10.     private static ThreadLocal<Integer> count = new ThreadLocal<Integer>(){  
    11.   
    12.         @Override  
    13.         protected Integer initialValue() {  
    14.             // TODO Auto-generated method stub  
    15.             return 0;  
    16.         }  
    17.           
    18.     };  
    19.       
    20.   
    21.     // 存钱  
    22.     public void addMoney(int money) {  
    23.         count.set(count.get()+money);  
    24.         System.out.println(System.currentTimeMillis() + "存进:" + money);  
    25.           
    26.     }  
    27.   
    28.     // 取钱  
    29.     public void subMoney(int money) {  
    30.         if (count.get() - money < 0) {  
    31.             System.out.println("余额不足");  
    32.             return;  
    33.         }  
    34.         count.set(count.get()- money);  
    35.         System.out.println(+System.currentTimeMillis() + "取出:" + money);  
    36.     }  
    37.   
    38.     // 查询  
    39.     public void lookMoney() {  
    40.         System.out.println("账户余额:" + count.get());  
    41.     }  
    42. }  

    运行效果:

    [html]  view plain  copy
    1. 余额不足  
    2. 账户余额:0  
    3.   
    4.   
    5. 余额不足  
    6. 账户余额:0  
    7.   
    8.   
    9. 1441794247939存进:100  
    10. 账户余额:100  
    11.   
    12.   
    13. 余额不足  
    14. 1441794248940存进:100  
    15. 账户余额:0  
    16.   
    17.   
    18. 账户余额:200  
    19.   
    20.   
    21. 余额不足  
    22. 账户余额:0  
    23.   
    24.   
    25. 1441794249941存进:100  
    26. 账户余额:300  

    看了运行效果,一开始一头雾水,怎么只让存,不让取啊?看看ThreadLocal的原理:

    如果使用ThreadLocal管理变量,则每一个使用该变量的线程都获得该变量的副本,副本之间相互独立,这样每一个线程都可以随意修改自己的变量副本,而不会对其他线程产生影响。现在明白了吧,原来每个线程运行的都是一个副本,也就是说存钱和取钱是两个账户,知识名字相同而已。所以就会发生上面的效果。

    ThreadLocal与同步机制 
    a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题

    b.前者采用以"空间换时间"的方法,后者采用以"时间换空间"的方式 



    同步的方法:

    一、同步方法

      即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁,当用此关键字修饰方法时, 内置锁会保护整个方法。在调用该方法前,需要获得内置锁,否则就处于阻塞状态。
    注: synchronized关键字也可以修饰静态方法,此时如果调用该静态方法,将会锁住整个类。

     

    二、同步代码块

      即有synchronized关键字修饰的语句块。 被该关键字修饰的语句块会自动被加上内置锁,从而实现同步
        代码如: 
    synchronized(object){ 
    }
        注:同步是一种高开销的操作,因此应该尽量减少同步的内容。通常没有必要同步整个方法,使用synchronized代码块同步关键代码即可。 
    复制代码
        package com.xhj.thread;
     
        /**
         * 线程同步的运用
         * 
         * @author XIEHEJUN
         * 
         */
        public class SynchronizedThread {
     
            class Bank {
                private int account = 100;
                public int getAccount() {
                    return account;
                }
     
                /**
                 * 用同步方法实现
                 * 
                 * @param money
                 */
                public synchronized void save(int money) {
                    account += money;
                }
     
                /**
                 * 用同步代码块实现
                 * 
                 * @param money
                 */
                public void save1(int money) {
                    synchronized (this) {
                        account += money;
                    }
                }
            }
    复制代码
    复制代码
    class NewThread implements Runnable {
                private Bank bank;
     
                public NewThread(Bank bank) {
                    this.bank = bank;
                }
     
                @Override
                public void run() {
                    for (int i = 0; i < 10; i++) {
                        // bank.save1(10);
                        bank.save(10);
                        System.out.println(i + "账户余额为:" + bank.getAccount());
                    }
                }
     
            }
     
            /**
             * 建立线程,调用内部类
             */
            public void useThread() {
                Bank bank = new Bank();
                NewThread new_thread = new NewThread(bank);
                System.out.println("线程1");
                Thread thread1 = new Thread(new_thread);
                thread1.start();
                System.out.println("线程2");
                Thread thread2 = new Thread(new_thread);
                thread2.start();
            }
     
            public static void main(String[] args) {
                SynchronizedThread st = new SynchronizedThread();
                st.useThread();
            }
     
        }
    复制代码

     

     
            
    =====================================

    示例加讲解

    同步是多线程中的重要概念。同步的使用可以保证在多线程运行的环境中,程序不会产生设计之外的错误结果。同步的实现方式有两种,同步方法同步块,这两种方式都要用到synchronized关键字。

    同步方法:给一个方法增加synchronized修饰符之后就可以使它成为同步方法,这个方法可以是静态方法和非静态方法,但是不能是抽象类的抽象方法,也不能是接口中的接口方法。下面代码是一个同步方法的示例:

    复制代码
    public synchronized void aMethod() { 
        // do something 
    } 
    
    public static synchronized void anotherMethod() { 
        // do something 
    } 
    复制代码

    线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时,这个对象的所有同步方法都被锁定了,在此期间,其他任何线程都不能访问这个对象的任意一个同步方法,直到这个线程执行完它所调用的同步方法并从中退出,从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后,其他线程是可以访问这个对象的所有非同步方法的。

    同步块:同步块是通过锁定一个指定的对象,来对同步块中包含的代码进行同步;而同步方法是对这个方法块里的代码进行同步,而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法呢?那么线程锁定的就不是这个类的对象了,也不是这个类自身,而是这个类对应的java.lang.Class类型的对象。同步方法和同步块之间的相互制约只限于同一个对象之间,所以静态同步方法只受它所属类的其它静态同步方法的制约,而跟这个类的实例(对象)没有关系。

    如果一个对象既有同步方法,又有同步块,那么当其中任意一个同步方法或者同步块被某个线程执行时,这个对象就被锁定了,其他线程无法在此时访问这个对象的同步方法,也不能执行同步块。

    synchronized 关键字用于保护共享数据。请大家注意“共享数据”,你一定要分清哪些数据是共享数据,请看下面的例子:

    复制代码
    public class ThreadTest implements Runnable{
    
    public synchronized void run(){
      for(int i=0;i<10;i++) {
        System.out.print(" " + i);
      }
    }
    
    public static void main(String[] args) {
      Runnable r1 = new ThreadTest(); //也可写成ThreadTest r1 = new ThreadTest();
      Runnable r2 = new ThreadTest();
      Thread t1 = new Thread(r1);
      Thread t2 = new Thread(r2);
      t1.start();
      t2.start();
    }}
    复制代码

     

    在这个程序中,run()虽然被加上了synchronized 关键字,但保护的不是共享数据。因为这个程序中的t1,t2 是两个对象(r1,r2)的线程。而不同的对象的数据是不同的,r1,r2 有各自的run()方法,所以输出结果无法预知。

    synchronized的目的是使同一个对象的多个线程,在某个时刻只有其中的一个线程可以访问这个对象的synchronized 数据。每个对象都有一个“锁标志”,当这个对象的一个线程访问这个对象的某个synchronized 数据时,这个对象的所有被synchronized 修饰的数据将被上锁(因为“锁标志”被当前线程拿走了),只有当前线程访问完它要访问的synchronized 数据时,当前线程才会释放“锁标志”,这样同一个对象的其它线程才有机会访问synchronized 数据。

    示例3:

    复制代码
    public class ThreadTest implements Runnable{
    
    public synchronized void run(){
      for(int i=0;i<10;i++){
        System.out.print(" " + i);
      }
    }
    
    public static void main(String[] args){
      Runnable r = new ThreadTest();
      Thread t1 = new Thread(r);
      Thread t2 = new Thread(r);
      t1.start();
      t2.start();
    }}
    复制代码

     

    如果你运行1000 次这个程序,它的输出结果也一定每次都是:0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9。因为这里的synchronized 保护的是共享数据。t1,t2 是同一个对象(r)的两个线程,当其中的一个线程(例如:t1)开始执行run()方法时,由于run()受synchronized保护,所以同一个对象的其他线程(t2)无法访问synchronized 方法(run 方法)。只有当t1执行完后t2 才有机会执行。

    示例4:

    复制代码
    public class ThreadTest implements Runnable{
    
    public void run(){
    
        synchronized(this){
        for(int i=0;i<10;i++){
            System.out.print(" " + i);
        }
    } 
    }
    
    public static void main(String[] args){
        Runnable r = new ThreadTest();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();
    }
    }    
    复制代码

     

    这个程序与示例3 的运行结果一样。在可能的情况下,应该把保护范围缩到最小,可以用示例4 的形式,this 代表“这个对象”。没有必要把整个run()保护起来,run()中的代码只有一个for循环,所以只要保护for 循环就可以了。

    示例5:

    复制代码
    public class ThreadTest implements Runnable{
    
    public void run(){
      for(int k=0;k<5;k++){
        System.out.println(Thread.currentThread().getName()+ " : for loop : " + k);
      }
    
    synchronized(this){
      for(int k=0;k<5;k++) {
        System.out.println(Thread.currentThread().getName()+ " : synchronized for loop : " + k);
      }} }
    
    public static void main(String[] args){
      Runnable r = new ThreadTest();
      Thread t1 = new Thread(r,"t1_name");
      Thread t2 = new Thread(r,"t2_name");
      t1.start();
      t2.start();
    } }
    复制代码

     

    运行结果:

    t1_name : for loop : 0

    t1_name : for loop : 1

    t1_name : for loop : 2

    t2_name : for loop : 0

    t1_name : for loop : 3

    t2_name : for loop : 1

    t1_name : for loop : 4

    t2_name : for loop : 2

    t1_name : synchronized for loop : 0

    t2_name : for loop : 3

    t1_name : synchronized for loop : 1

    t2_name : for loop : 4

    t1_name : synchronized for loop : 2

    t1_name : synchronized for loop : 3

    t1_name : synchronized for loop : 4

    t2_name : synchronized for loop : 0

    t2_name : synchronized for loop : 1

    t2_name : synchronized for loop : 2

    t2_name : synchronized for loop : 3

    t2_name : synchronized for loop : 4

    第一个for 循环没有受synchronized 保护。对于第一个for 循环,t1,t2 可以同时访问。运行结果表明t1 执行到了k=2 时,t2 开始执行了。t1 首先执行完了第一个for 循环,此时t2还没有执行完第一个for 循环(t2 刚执行到k=2)。t1 开始执行第二个for 循环,当t1的第二个for 循环执行到k=1 时,t2 的第一个for 循环执行完了。t2 想开始执行第二个for 循环,但由于t1 首先执行了第二个for 循环,这个对象的锁标志自然在t1 手中(synchronized 方法的执行权也就落到了t1 手中),在t1 没执行完第二个for 循环的时候,它是不会释放锁标志的。所以t2 必须等到t1 执行完第二个for 循环后,它才可以执行第二个for 循环。

    =====================================

    三、wait与notify

    wait():使一个线程处于等待状态,并且释放所持有的对象的lock。

    sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用此方法要捕捉InterruptedException异常。
    notify():唤醒一个处于等待状态的线程,注意的是在调用此方法的时候,并不能确切的唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且不是按优先级。
    Allnotity():唤醒所有处入等待状态的线程,注意并不是给所有唤醒线程一个对象的锁,而是让它们竞争。

    详细见:wait、notify、notifyAll的使用方法

    四、使用特殊域变量(volatile)实现线程同步

        a.volatile关键字为域变量的访问提供了一种免锁机制
        b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新
        c.因此每次使用该域就要重新计算,而不是使用寄存器中的值 
        d.volatile不会提供任何原子操作,它也不能用来修饰final类型的变量 
        
        例如: 
            在上面的例子当中,只需在account前面加上volatile修饰,即可实现线程同步。 
        
        代码实例: 
     
    复制代码
            //只给出要修改的代码,其余代码与上同
            class Bank {
                //需要同步的变量加上volatile
                private volatile int account = 100;
     
                public int getAccount() {
                    return account;
                }
                //这里不再需要synchronized 
                public void save(int money) {
                    account += money;
                }
            }
    复制代码
        注:多线程中的非同步问题主要出现在对域的读写上,如果让域自身避免这个问题,则就不需要修改操作该域的方法。 
        用final域,有锁保护的域和volatile域可以避免非同步的问题。 

    五、使用重入锁实现线程同步

        在 JavaSE5.0中新增了一个java.util.concurrent包来支持同步。 
        ReentrantLock类是可重入、互斥、实现了Lock接口的锁,它与使用synchronized方法和快具有相同的基本行为和语义,并且扩展了其能力。
     ReenreantLock类的常用方法有:
    ReentrantLock() : 创建一个ReentrantLock实例 
    lock() : 获得锁 
    unlock() : 释放锁 
    注:ReentrantLock()还有一个可以创建公平锁的构造方法,但由于能大幅度降低程序运行效率,不推荐使用 
            
        例如: 
            在上面例子的基础上,改写后的代码为: 
    复制代码
           //只给出要修改的代码,其余代码与上同
            class Bank {
                
                private int account = 100;
                //需要声明这个锁
                private Lock lock = new ReentrantLock();
                public int getAccount() {
                    return account;
                }
                //这里不再需要synchronized 
                public void save(int money) {
                    lock.lock();
                    try{
                        account += money;
                    }finally{
                        lock.unlock();
                    }
                    
                }
            }
    复制代码
         注:关于Lock对象和synchronized关键字的选择: 
            a.最好两个都不用,使用一种java.util.concurrent包提供的机制,能够帮助用户处理所有与锁相关的代码。 
            b.如果synchronized关键字能满足用户的需求,就用synchronized,因为它能简化代码 
            c.如果需要更高级的功能,就用ReentrantLock类,此时要注意及时释放锁,否则会出现死锁,通常在finally代码释放锁 
     

    六、使用局部变量实现线程同步

        如果使用ThreadLocal管理变量,则每一个使用该变量的线程都获得该变量的副本,副本之间相互独立,这样每一个线程都可以随意修改自己的变量副本,而不会对其他线程产生影响。
         ThreadLocal 类的常用方法
    ThreadLocal() : 创建一个线程本地变量 
    get() : 返回此线程局部变量的当前线程副本中的值 
    initialValue() : 返回此线程局部变量的当前线程的"初始值" 
    set(T value) : 将此线程局部变量的当前线程副本中的值设置为value
        例如: 
            在上面例子基础上,修改后的代码为: 
    复制代码
            //只改Bank类,其余代码与上同
            public class Bank{
                //使用ThreadLocal类管理共享变量account
                private static ThreadLocal<Integer> account = new ThreadLocal<Integer>(){
                    @Override
                    protected Integer initialValue(){
                        return 100;
                    }
                };
                public void save(int money){
                    account.set(account.get()+money);
                }
                public int getAccount(){
                    return account.get();
                }
            }
    复制代码
        注:ThreadLocal与同步机制 
            a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题。 
            b.前者采用以"空间换时间"的方法,后者采用以"时间换空间"的方式
     

    七、使用阻塞队列实现线程同步

    前面5种同步方式都是在底层实现的线程同步,但是我们在实际开发当中,应当尽量远离底层结构。 使用javaSE5.0版本中新增的java.util.concurrent包将有助于简化开发。 本小节主要是使用LinkedBlockingQueue<E>来实现线程的同步 LinkedBlockingQueue<E>是一个基于已连接节点的,范围任意的blocking queue。 队列是先进先出的顺序(FIFO),关于队列以后会详细讲解~LinkedBlockingQueue 类常用方法 LinkedBlockingQueue() : 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue put(E e) : 在队尾添加一个元素,如果队列满则阻塞 size() : 返回队列中的元素个数 take() : 移除并返回队头元素,如果队列空则阻塞代码实例: 实现商家生产商品和买卖商品的同步

     

    注:BlockingQueue<E>定义了阻塞队列的常用方法,尤其是三种添加元素的方法,我们要多加注意,当队列满时:

      add()方法会抛出异常

      offer()方法返回false

      put()方法会阻塞

     

     

    7.使用原子变量实现线程同步

     

    需要使用线程同步的根本原因在于对普通变量的操作不是原子的。

    那么什么是原子操作呢?原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作即-这几种行为要么同时完成,要么都不完成。在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类,使用该类可以简化线程同步。其中AtomicInteger 表可以用原子方式更新int的值,可用在应用程序中(如以原子方式增加的计数器),但不能用于替换Integer;可扩展Number,允许那些处理机遇数字类的工具和实用工具进行统一访问。

    AtomicInteger类常用方法:

    AtomicInteger(int initialValue) : 创建具有给定初始值的新的

    AtomicIntegeraddAddGet(int dalta) : 以原子方式将给定值与当前值相加

    get() : 获取当前值

    代码实例:

    只改Bank类,其余代码与上面第一个例子同

    复制代码
    class Bank {
        private AtomicInteger account = new AtomicInteger(100);
        public AtomicInteger getAccount() {
            return account; 
        } 
        public void save(int money) {
            account.addAndGet(money);
        }
    }
    复制代码

    补充--原子操作主要有:  

    对于引用变量和大多数原始变量(long和double除外)的读写操作;  

    对于所有使用volatile修饰的变量(包括long和double)的读写操作。


    展开全文
    weixin_39214481 2018-05-28 22:11:07
  • qq_44664231 2020-04-30 15:13:28
  • weixin_38719347 2018-07-26 17:20:33
  • 4星
    2KB xiaolongdehao 2011-07-28 10:23:52
  • yz2015 2018-03-04 14:09:15
  • qq_33819764 2018-08-16 10:21:18
  • qq_38923792 2019-07-17 09:37:23
  • qq_34147021 2019-03-08 01:47:21
  • coolwriter 2018-05-23 16:01:27
  • u011028345 2017-06-18 21:24:18
  • babauyang 2012-05-07 14:59:21
  • youngpan1101 2017-05-25 19:53:09
  • m0_37621078 2019-03-20 00:08:29
  • u022812849 2020-10-22 16:37:21
  • u012240455 2018-05-31 10:00:32
  • qq_41786692 2018-06-18 00:45:16
  • deguotiantang 2017-02-27 16:34:40
  • yoonerloop 2018-07-25 21:31:26
  • wb175208 2018-09-15 12:06:04
  • d06110902002 2018-09-23 11:56:05
  • u010977122 2016-11-09 21:28:05
  • xichanjuan6481 2018-12-24 21:24:33
  • weixin_43895254 2020-08-25 17:12:44
  • linchengshen_ 2018-05-30 23:03:28
  • u014635472 2017-02-16 00:22:07
  • mu_wind 2020-03-31 15:35:49

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 676,277
精华内容 270,510
关键字:

多线程同步怎么实现