精华内容
下载资源
问答
  • 高分悬赏:Java语言多线程倒计时怎么同步输出,怎么多线程实现 高分悬赏:Java语言多线程倒计时怎么同步输出,怎么多线程实现
  • Java提供了很多同步操作,比如synchronized关键字、wait/notifyAll、ReentrantLock、Condition、一些并发包下的工具类、Semaphore,ThreadLocal、AbstractQueuedSynchronizer等。

    http://blog.csdn.net/pdw2009/article/details/52373947

    Java提供了很多同步操作,比如synchronized关键字、wait/notifyAll、ReentrantLock、Condition、一些并发包下的工具类、Semaphore,ThreadLocal、AbstractQueuedSynchronizer等。

    ReentrantLock可重入锁

    ReentrantLock可重入锁是jdk内置的一个锁对象,可以用来实现同步,基本使用方法如下:

    public class ReentrantLockTest {
    
        private ReentrantLock lock = new ReentrantLock();
    
        public void execute() {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + " do something synchronize");
                try {
                    Thread.sleep(5000l);
                } catch (InterruptedException e) {
                    System.err.println(Thread.currentThread().getName() + " interrupted");
                    Thread.currentThread().interrupt();
                }
            } finally {
                lock.unlock();
            }
        }
    
        public static void main(String[] args) {
            ReentrantLockTest reentrantLockTest = new ReentrantLockTest();
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    reentrantLockTest.execute();
                }
            });
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    reentrantLockTest.execute();
                }
            });
            thread1.start();
            thread2.start();
        }
    
    }
    

    输出:

    Thread-0 do something synchronize
    // 隔了5秒钟 输入下面
    Thread-1 do something synchronize
    

    这个例子表示同一时间段只能有1个线程执行execute方法。

    可重入锁中可重入表示的意义在于对于同一个线程,可以继续调用加锁的方法,而不会被挂起。可重入锁内部维护一个计数器,对于同一个线程调用lock方法,计数器+1,调用unlock方法,计数器-1。

    举个例子再次说明一下可重入的意思,在一个加锁方法execute中调用另外一个加锁方法anotherLock并不会被挂起,可以直接调用(调用execute方法时计数器+1,然后内部又调用了anotherLock方法,计数器+1,变成了2):

    public void execute() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " do something synchronize");
            try {
                anotherLock();
                Thread.sleep(5000l);
            } catch (InterruptedException e) {
                System.err.println(Thread.currentThread().getName() + " interrupted");
                Thread.currentThread().interrupt();
            }
        } finally {
            lock.unlock();
        }
    }
    
    public void anotherLock() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " invoke anotherLock");
        } finally {
            lock.unlock();
        }
    }
    

    输出:

    Thread-0 do something synchronize
    Thread-0 invoke anotherLock
    // 隔了5秒钟 输入下面
    Thread-1 do something synchronize
    Thread-1 invoke anotherLock
    

    synchronized关键字

    synchronized关键跟ReentrantLock一样,也支持可重入锁。但是它是一个关键字,是一种语法级别的同步方式,称为内置锁:

    public class SynchronizedKeyWordTest {
    
        public synchronized void execute() {
                System.out.println(Thread.currentThread().getName() + " do something synchronize");
            try {
                anotherLock();
                Thread.sleep(5000l);
            } catch (InterruptedException e) {
                System.err.println(Thread.currentThread().getName() + " interrupted");
                Thread.currentThread().interrupt();
            }
        }
    
        public synchronized void anotherLock() {
            System.out.println(Thread.currentThread().getName() + " invoke anotherLock");
        }
    
        public static void main(String[] args) {
            SynchronizedKeyWordTest reentrantLockTest = new SynchronizedKeyWordTest();
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    reentrantLockTest.execute();
                }
            });
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    reentrantLockTest.execute();
                }
            });
            thread1.start();
            thread2.start();
        }
    
    }
    

    输出结果跟ReentrantLock一样,这个例子说明内置锁可以作用在方法上。它还可以作用到变量,静态方法上。

    synchronized跟ReentrantLock相比,有几点局限性:

    1. 加锁的时候不能设置超时。ReentrantLock有提供tryLock方法,可以设置超时时间,如果超过了这个时间并且没有获取到锁,就会放弃,而synchronized却没有这种功能
    2. ReentrantLock可以使用多个Condition,而synchronized却只能有1个
    3. 不能中断一个试图获得锁的线程
    4. ReentrantLock可以选择公平锁和非公平锁
    5. ReentrantLock可以获得正在等待线程的个数,计数器等

    Condition条件对象

    条件对象的意义在于对于一个已经获取锁的线程,如果还需要等待其他条件才能继续执行的情况下,才会使用Condition条件对象。

    public class ConditionTest {
    
        public static void main(String[] args) {
            ReentrantLock lock = new ReentrantLock();
            Condition condition = lock.newCondition();
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    lock.lock();
                    try {
                        System.out.println(Thread.currentThread().getName() + " run");
                        System.out.println(Thread.currentThread().getName() + " wait for condition");
                        try {
                            condition.await();
                            System.out.println(Thread.currentThread().getName() + " continue");
                        } catch (InterruptedException e) {
                            System.err.println(Thread.currentThread().getName() + " interrupted");
                            Thread.currentThread().interrupt();
                        }
                    } finally {
                        lock.unlock();
                    }
                }
            });
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    lock.lock();
                    try {
                        System.out.println(Thread.currentThread().getName() + " run");
                        System.out.println(Thread.currentThread().getName() + " sleep 5 secs");
                        try {
                            Thread.sleep(5000l);
                        } catch (InterruptedException e) {
                            System.err.println(Thread.currentThread().getName() + " interrupted");
                            Thread.currentThread().interrupt();
                        }
                        condition.signalAll();
                    } finally {
                        lock.unlock();
                    }
                }
            });
            thread1.start();
            thread2.start();
        }
    
    }
    

    这个例子中thread1执行到condition.await()时,当前线程会被挂起,直到thread2调用了condition.signalAll()方法之后,thread1才会重新被激活执行。

    这里需要注意的是thread1调用Condition的await方法之后,thread1线程释放锁,然后马上加入到Condition的等待队列,由于thread1释放了锁,thread2获得锁并执行,thread2执行signalAll方法之后,Condition中的等待队列thread1被取出并加入到AQS中,接下来thread2执行完毕之后释放锁,由于thread1已经在AQS的等待队列中,所以thread1被唤醒,继续执行。

    wait/notifyAll 方式

    wait/notifyAll方式跟ReentrantLock/Condition方式的原理是一样的。

    Java中每个对象都拥有一个内置锁,在内置锁中调用wait,notify方法相当于调用锁的Condition条件对象的await和signalAll方法。

    使用wait/notifyAll实现上面的那个Condition例子:

    public class WaitNotifyAllTest {
    
        public synchronized void doWait() {
            System.out.println(Thread.currentThread().getName() + " run");
            System.out.println(Thread.currentThread().getName() + " wait for condition");
            try {
                this.wait();
                System.out.println(Thread.currentThread().getName() + " continue");
            } catch (InterruptedException e) {
                System.err.println(Thread.currentThread().getName() + " interrupted");
                Thread.currentThread().interrupt();
            }
        }
    
        public synchronized void doNotify() {
            try {
                System.out.println(Thread.currentThread().getName() + " run");
                System.out.println(Thread.currentThread().getName() + " sleep 5 secs");
                Thread.sleep(5000l);
                this.notifyAll();
            } catch (InterruptedException e) {
                System.err.println(Thread.currentThread().getName() + " interrupted");
                Thread.currentThread().interrupt();
            }
        }
    
        public static void main(String[] args) {
            WaitNotifyAllTest waitNotifyAllTest = new WaitNotifyAllTest();
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    waitNotifyAllTest.doWait();
                }
            });
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    waitNotifyAllTest.doNotify();
                }
            });
            thread1.start();
            thread2.start();
        }
    
    }
    

    这里需要注意的是由于Condition是由锁创建的,所以调用wait/notifyAll方法的时候需要获得当前线程的锁,否则会发生IllegalMonitorStateException异常。

    ThreadLocal

    ThreadLocal是一种把变量放到线程本地的方式来实现线程同步的。

    比如SimpleDateFormat不是一个线程安全的类,可以使用ThreadLocal实现同步。

    public class ThreadLocalTest {
    
        private static ThreadLocal<SimpleDateFormat> dateFormatThreadLocal = new ThreadLocal<SimpleDateFormat>() {
            @Override
            protected SimpleDateFormat initialValue() {
                return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            }
        };
    
        public static void main(String[] args) {
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    Date date = new Date();
                    System.out.println(dateFormatThreadLocal.get().format(date));
                }
            });
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    Date date = new Date();
                    System.out.println(dateFormatThreadLocal.get().format(date));
                }
            });
            thread1.start();
            thread2.start();
        }
    
    }
    

    Semaphore信号量

    Semaphore信号量被用于控制特定资源在同一个时间被访问的个数。类似连接池的概念,保证资源可以被合理的使用。可以使用构造器初始化资源个数:

    public class SemaphoreTest {
    
        private static Semaphore semaphore = new Semaphore(2);
    
        public static void main(String[] args) {
            for(int i = 0; i < 5; i ++) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            semaphore.acquire();
                            System.out.println(Thread.currentThread().getName() + " " + new Date());
                            Thread.sleep(5000l);
                            semaphore.release();
                        } catch (InterruptedException e) {
                            System.err.println(Thread.currentThread().getName() + " interrupted");
                        }
                    }
                }).start();
            }
        }
    
    }
    

    输出:

    Thread-1 Mon Apr 18 18:03:46 CST 2016
    Thread-0 Mon Apr 18 18:03:46 CST 2016
    Thread-3 Mon Apr 18 18:03:51 CST 2016
    Thread-2 Mon Apr 18 18:03:51 CST 2016
    Thread-4 Mon Apr 18 18:03:56 CST 2016
    

    并发包下的工具类

    一般情况下,我们不会使用wait/notifyAll或者ReentrantLock这种比较底层的类,而是使用并发包下提供的一些工具类。

    CountDownLatch

    CountDownLatch是一个计数器,它的构造方法中需要设置一个数值,用来设定计数的次数。每次调用countDown()方法之后,这个计数器都会减去1,CountDownLatch会一直阻塞着调用await()方法的线程,直到计数器的值变为0。

    public class CountDownLatchTest {
    
        public static void main(String[] args) {
            CountDownLatch countDownLatch = new CountDownLatch(5);
            for(int i = 0; i < 5; i ++) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread().getName() + " " + new Date() + " run");
                        try {
                            Thread.sleep(5000l);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        countDownLatch.countDown();
                    }
                }).start();
            }
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("all thread over");
        }
    
    }
    

    输出:

    Thread-2 Mon Apr 18 18:18:30 CST 2016 run
    Thread-3 Mon Apr 18 18:18:30 CST 2016 run
    Thread-4 Mon Apr 18 18:18:30 CST 2016 run
    Thread-0 Mon Apr 18 18:18:30 CST 2016 run
    Thread-1 Mon Apr 18 18:18:30 CST 2016 run
    all thread over
    

    CyclicBarrier

    CyclicBarrier阻塞调用的线程,直到条件满足时,阻塞的线程同时被打开。

    调用await()方法的时候,这个线程就会被阻塞,当调用await()的线程数量到达屏障数的时候,主线程就会取消所有被阻塞线程的状态。

    在CyclicBarrier的构造方法中,还可以设置一个barrierAction。

    在所有的屏障都到达之后,会启动一个线程来运行这里面的代码。

    public class CyclicBarrierTest {
    
        public static void main(String[] args) {
            Random random = new Random();
            CyclicBarrier cyclicBarrier = new CyclicBarrier(5);
            for(int i = 0; i < 5; i ++) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        int secs = random.nextInt(5);
                        System.out.println(Thread.currentThread().getName() + " " + new Date() + " run, sleep " + secs + " secs");
                        try {
                            Thread.sleep(secs * 1000);
                            cyclicBarrier.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } catch (BrokenBarrierException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + " " + new Date() + " runs over");
                    }
                }).start();
            }
        }
    
    }
    

    相比CountDownLatch,CyclicBarrier是可以被循环使用的,而且遇到线程中断等情况时,还可以利用reset()方法,重置计数器,从这些方面来说,CyclicBarrier会比CountDownLatch更加灵活一些。

    AbstractQueuedSynchronizer

    AQS是很多同步工具类的基础,比如ReentrentLock里的公平锁和非公平锁,Semaphore里的公平锁和非公平锁,CountDownLatch里的锁等他们的底层都是使用AbstractQueuedSynchronizer完成的。

    基于AbstractQueuedSynchronizer自定义实现一个独占锁:

    public class MySynchronizer extends AbstractQueuedSynchronizer {
    
        @Override
        protected boolean tryAcquire(int arg) {
            if(compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }
    
        @Override
        protected boolean tryRelease(int arg) {
            setState(0);
            setExclusiveOwnerThread(null);
            return true;
        }
    
        public void lock() {
            acquire(1);
        }
    
        public void unlock() {
            release(1);
        }
    
        public static void main(String[] args) {
            MySynchronizer mySynchronizer = new MySynchronizer();
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    mySynchronizer.lock();
                    try {
                        System.out.println(Thread.currentThread().getName() + " run");
                        System.out.println(Thread.currentThread().getName() + " will sleep 5 secs");
                        try {
                            Thread.sleep(5000l);
                            System.out.println(Thread.currentThread().getName() + " continue");
                        } catch (InterruptedException e) {
                            System.err.println(Thread.currentThread().getName() + " interrupted");
                            Thread.currentThread().interrupt();
                        }
                    } finally {
                        mySynchronizer.unlock();
                    }
                }
            });
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    mySynchronizer.lock();
                    try {
                        System.out.println(Thread.currentThread().getName() + " run");
                    } finally {
                        mySynchronizer.unlock();
                    }
                }
            });
            thread1.start();
            thread2.start();
        }
    
    }
    

    MySynchronizer并没有实现可重入功能,只是简单的一个独占锁。


    展开全文
  • 多线程线程:类似执行一个命令,多线程:并发执行多条命令。多线程的优点:1....1.多线程会出现线程安全问题,线程同步可以有效的保证线程安全。 2.当主线程依赖两个子线程结果的时候,需要线程同步如何实...

    4f4d6031e0c266fa0a9133846ab5a54f.png

    多线程

    线程:类似执行一个命令,多线程:并发执行多条命令。

    多线程的优点:
    1.充分利用cpu的性能。
    2.提高系统性能。
    3.同一时刻处理可以处理不同的命令

    线程同步

    即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作,为什么需要它呢?

    1.多线程会出现线程安全问题,线程同步可以有效的保证线程安全。
    2.当主线程依赖两个子线程结果的时候,需要线程同步

    如何实现线程同步?
    1.加锁,如:synchronized。
    2.通过wait和和notify(和notifyAll),推荐使用notifyAll。
    3.线程池callback。
    4.join()。
    5.CountDownLatch(java SDK包)。
    6.CyclicBarrier(java SDK包)。
    等等。。。。。。。。。。。。。。。。

    这里只介绍5、6两种

    我们先来看一个没有加入线程同步的代码:

    public static  void hello(){
            System.out.println("线程:"+Thread.currentThread().getName()+" 执行了。。。。。。。。。");
        }
    
        public static void main(String[] args) {
            //线程1
            Thread t1 = new Thread(() -> {
                hello();
            });
            t1.start();
            //线程2
            Thread t2 = new Thread(() -> {
                hello();
            });
            t2.start();
            System.out.println("主函数执行完毕。。。。。。。。。");
        }

    打印结果:

    df59a8c569848258723fb2416178949a.png


    main方法的输出语句居然比两个子线程先执行,为什么呢?因为main是主线程,t1、t2是两个子线程,由于线程的执行顺序是无序的,所以就会导致每次的执行结果都不相同,现在我想实现当t1、t2执行完成之后在执行main方法的输出语句,该如何实现呢?只需要给t1、t2分别加一个方法即可:

    public static  void hello(){
            System.out.println("线程:"+Thread.currentThread().getName()+" 执行了。。。。。。。。。");
        }
    
        public static void main(String[] args) {
            //线程1
            Thread t1 = new Thread(() -> {
                hello();
            });
            t1.start();
            //线程2
            Thread t2 = new Thread(() -> {
                hello();
            });
            t2.start();
    
            try {
                t1.join();
                t2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("主函数执行完毕。。。。。。。。。");
        }

    结果如下:

    f14c89052e3f23e1b277da698413ad7a.png

    为什么join(),可以实现线程同步呢?join()源码如下:

    1b6d849a54c04cc043c5d5b0dde9e09d.png

    很明显,这里使用while做了循环等待,让线程不往下执行,达到线程同步(等待)的效果。

    然而我们平时的开发过程中基本不会这么创建线程,一般都是使用线程池,那在使用线程池的情况下如何让线程实现同步呢?

    我们先试试自己写一个方法让它实现同步,代码如下:

        public static  void hello(){
            String name = Thread.currentThread().getName();
            try {
                System.out.println("线程:"+name+" 休眠开始。。。。。。。。。。。。");
                Thread.sleep(1000);
                System.out.println("线程:"+name+" 休眠结束。。。。。。。。。。。。");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
        }
    
        public static  void main(String[] args)  {
            // 计数器初始化为2
            AtomicInteger count = new AtomicInteger(2);
            executor.execute(() ->{
                hello();
                count.decrementAndGet();
            });
            executor.execute(() ->{
                hello();
                count.decrementAndGet();
            });
            //等待两个线程执行完毕
            while(count.get() != 0){
    
            }
    
            System.out.println("我是在两个线程执行之后才执行的内容");
    
        }
    count:用于统计线程执行的数量,线程执行-1;AtomicInteger:原子类,可以在多线程中保证共享变量的安全。
    decrementAndGet:自减并返回自减以后的结果(原子操作)。
    while:线程同步的重点:这里主要是让主线程处于循环状态,直到count被减为0,也就意味着两个子线程都已执行完毕。

    但是我不推荐这么做,为什么呢?因为java SDK给我们提供了现成的方法,我们为啥还要自己去手动实现呢?下面我们就来看看 CountDownLatch是如何实现线程同步:

    // 创建2个线程的线程池
        private static  Executor executor =   Executors.newFixedThreadPool(2);
    
        public static  void hello(){
            String name = Thread.currentThread().getName();
            try {
                System.out.println("线程:"+name+" 休眠开始。。。。。。。。。。。。");
                Thread.sleep(1000);
                System.out.println("线程:"+name+" 休眠结束。。。。。。。。。。。。");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
        }
    
        public static  void main(String[] args)  {
            
            //这里需要注意一点,那就是实例化CountDownLatch的初始大小,一定要和你需要等待线程的数量相同,
            //小了会导致等待的线程提前执行。
            //大了会导致线程一直处于无限循环当中
            CountDownLatch countDownLatch = new CountDownLatch(2);
            executor.execute(() ->{
                hello();
                countDownLatch.countDown();
            });
            executor.execute(() ->{
                hello();
                countDownLatch.countDown();
            });
            //等待两个线程执行完毕
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是在两个线程执行之后才执行的内容");
    
        }

    为了效果明显,我特意在hello方法让线程休眠1秒。
    countDownLatch:实现线程同步的关键,实例化一个需要等待的线程数量
    countDownLatch.countDown():等待线程数-1。
    countDownLatch.await();让主线程处于等待状态,直到等待的线程被减为0(注意:这里必须要做异常捕获线程中断的异常:(InterruptedException);

    上面代码结果如下:

    d1704a2a088a4546ab7ece86d5a45cdc.png

    这里需要注意一点:CountDownLatch的初始大小是不会被重置的,所以使用这个解决方案的时候需要手动重置CountDownLatch线程等待的初始大小。
    实现原理:

    9cdf461bcf6573f599fd91bed59ed88a.png


    其实查看源码,他的实现方式和我之前使用的while类似,他这里用了for的无限循环,直到等待的线程被减为0;

    那有没有不需要重新设置线程等待的工具类呢?肯定是有的,那就是接下来要说的:CyclicBarrier

    CyclicBarrier

    主要通过线程回调来实现线程等待,这里的实现方式稍微做了一下修改:

    // 创建3个线程的线程池,其中一个线程用于回调处理主线程的事情
        private static  Executor executor =   Executors.newFixedThreadPool(3);
    
        public static  void hello(){
            String name = Thread.currentThread().getName();
            try {
                System.out.println("线程:"+name+" 休眠开始。。。。。。。。。。。。");
                Thread.sleep(1000);
                System.out.println("线程:"+name+" 休眠结束。。。。。。。。。。。。");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
        }
    
        public static  void main(String[] args)  {
    
            //这里需要注意一点,那就是实例化CountDownLatch的初始大小,一定要和你需要等待线程的数量相同,
            //小了会导致等待的线程提前执行。
            //大了会导致线程一直处于无限循环当中
            final CyclicBarrier barrier = new CyclicBarrier(2, ()->{ executor.execute(()->printAfter()); });
            executor.execute(() ->{
                hello();
                try {
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
            executor.execute(() ->{
                hello();
                try {
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
    
        /**
         * 两个线程执行完毕之后执行此方法
         */
        private static void printAfter() {
    
            System.out.println("我是在两个线程执行之后才执行的内容");
        }

    cb36c76b8ed4dc0d63159ebeab29ac53.png

    这里需要注意一点,那就是主函数的输出语句已经不放在mian方法中了,而是写在了barrier的回调方法中。当等待的线程执行完毕之后CyclicBarrier的等待线程数会被重置。

    CyclicBarrier与CountDownLatch区别
    CountDownLatch:解决一个线程等待多个线程场景。
    CyclicBarrier:解决一组线程之间的等待场景。
    CyclicBarrier支持重置功能,CountDownLatch不支持,这点需要特别注意。

    展开全文
  • 通过实现Runnable接口创建的线程可能会出现被共享的资源,被线程同时操作,并导致数据不准确的现象,那我们怎么去保护我们的敏感数据的,必须让共享的数据在一个特定的操作时间内只能由一个线程来进行操作,这,...

    Java线程同步

     在之前的文章《Java的Thread类的两种实现方式的区别》中,我们发现,通过实现Runnable接口创建的线程可能会出现被共享的资源,被多个线程同时操作,并导致数据不准确的现象,那我们怎么去保护我们的敏感数据的,必须让共享的数据在一个特定的操作时间内只能由一个线程来进行操作,这,便是线程同步的概念。

     首先来看一下不同步时的代码:

        //Bank
        public class Bank {
            private int money = 0;
    
            public void addMoney(int m) {
                money += m;
            }
    
            public void subMoney(int m) {
                money -= m;
            }
    
            public void getmoney() {
                System.out.println("Money:" + money);
            }
        }
    
        //实现runnable接口的类
        public class SynchronizeRunnable implements Runnable {
    
            private Bank bank=new Bank();
    
            @Override
            public void run(){
                for (int i = 0; i <1000 ; i++) {
                    bank.addMoney(1);
                }
                bank.getmoney();
            }
        }
    
        //执行方法
        public  void  threadone() throws Exception{
            Runnable runnable= new SynchronizeRunnable();
            Thread thread1=new Thread(runnable);
            Thread thread2=new Thread(runnable);
            thread1.start();
            thread2.start();
        }
    
    

    执行结果如下:

    Money:1798
    Money:1798
    

    可以看到,由两个线程同时来进行加钱的操作,每个线程都加1000块,那么理论值是2000,而结果却是1798,这便是多个线程同时操作一个资源的结果,必须要对关键资源进行线程同步,才可以保护我们的数据。


    本文介绍三种方法来实现线程同步。在了解线程同步的方法之前我们要提前了解一下synchronized关键字,使用了synchronized,就可以对特定的资源、方法等添加同步锁。

    1.使用同步代码块

    事实上我们看到,加钱的操作,核心知识这一行代码:

    money += m;
    

    我们只需要让这一行代码线程同步即可,修改后的Bank类如下:

    public class Bank {
        private int money = 0;
    
        public void addMoney(int m) {
            synchronized (this){
                money += m;
            }
        }
    
        public void subMoney(int m) {
            money -= m;
        }
    
        public void getmoney() {
            System.out.println("Money:" + money);
        }
    }
    

    运行结果如下:

    Money:2000
    Money:2000
    

    synchronized关键字会锁定括号里的资源。

    2.使用同步方法

    除了同步代码块以外,我们还可以对方法使用synchronized关键字来进行修饰,意味着同一时间只有一个线程可以执行此方法。修改后的Bank类如下:

    public class Bank {
        private int money = 0;
    
        public synchronized void addMoney(int m) {
            money += m;
        }
    
        public void subMoney(int m) {
            money -= m;
        }
    
        public void getmoney() {
            System.out.println("Money:" + money);
        }
    }
    

    结果如下:

    Money:2000
    Money:2000
    

    同步方法在执行时会锁定整个对象。

    注:由于同步是一个高开销的工作,会极大浪费CPU资源,所以要尽量减少同步的内容,一般能同步代码块的时候没必要同步整个类。

    注:synchronized还可以修饰静态方法,在修饰静态方法时,只要方法被同步,整个类都会被锁定。

    3.使用重入锁实现线程同步

     synchronized关键字在实际业务中有时会满足不了复杂的业务逻辑,所以在java5中引入了java.util.concurrent包来辅助线程同步问题。ReentrantLock()是一种可重入、互斥、实现了lock接口的锁,可以用它来实现线程同步。

     ReenTrantLock类有标准的使用规范:

        //首先实例化
        private Lock lock= new ReentrantLock();
    
        //锁定后要紧跟Try方法,并且在finally第一行解锁
        //try语句块内写需要线程同步的代码块
        public void addMoney(int m) {
            lock.lock();
            try {
                money += m;
            }finally {
                lock.unlock();
            }
        }
    

    Bank代码如下:

    public class Bank {
        private int money = 0;
    
        private Lock lock= new ReentrantLock();
    
        public void addMoney(int m) {
            lock.lock();
            try {
                money += m;
            }finally {
                lock.unlock();
            }
        }
    
        public void subMoney(int m) {
            money -= m;
        }
    
        public void getmoney() {
            System.out.println("Money:" + money);
        }
    }
    

    执行结果如下:

    Money:2000
    Money:2000
    

    注:一般为了代码的简洁能用synchronized实现的功能就不用ReentrantLock


    反思

     线程同步解决了多个线程争抢操作同一个资源时的数据错误,通过锁定一部分资源,其他的线程要操作时必须要等正在操作的线程执行完释放代码块才可以操作,那有没有可能两个线程都在等待对方释放资源呢?这便是线程死锁。

    展开全文
  • 多线程线程:类似执行一个命令,多线程:并发执行多条命令。多线程的优点: 1.充分利用cpu的性能。 2.提高系统性能。 3.同一时刻处理可以处理不同...当主线程依赖两个子线程结果的时候,需要线程同步如何实现线程同...

    多线程

    线程:类似执行一个命令,多线程:并发执行多条命令。

    多线程的优点: 1.充分利用cpu的性能。 2.提高系统性能。 3.同一时刻处理可以处理不同的命令

    线程同步

    即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作,为什么需要它呢?

    1.多线程会出现线程安全问题,线程同步可以有效的保证线程安全。 2.当主线程依赖两个子线程结果的时候,需要线程同步

    如何实现线程同步?

    1.加锁,如:synchronized。

    2.通过wait和和notify(和notifyAll),推荐使用notifyAll。

    3.线程池callback。

    4.join()。

    5.CountDownLatch(java SDK包)。

    6.CyclicBarrier(java SDK包)。

    等等。。。。。。。。。。。。。。。。

    这里只介绍5、6两种

    我们先来看一个没有加入线程同步的代码:

    public static  void hello(){        System.out.println("线程:"+Thread.currentThread().getName()+" 执行了。。。。。。。。。");    }    public static void main(String[] args) {        //线程1        Thread t1 = new Thread(() -> {            hello();        });        t1.start();        //线程2        Thread t2 = new Thread(() -> {            hello();        });        t2.start();        System.out.println("主函数执行完毕。。。。。。。。。");    }

    打印结果:

    8a1c5e166992fbf6d5f6c1f5b3e3c733.png

    main方法的输出语句居然比两个子线程先执行,为什么呢?因为main是主线程,t1、t2是两个子线程,由于线程的执行顺序是无序的,所以就会导致每次的执行结果都不相同,现在我想实现当t1、t2执行完成之后在执行main方法的输出语句,该如何实现呢?只需要给t1、t2分别加一个方法即可:

    public static  void hello(){        System.out.println("线程:"+Thread.currentThread().getName()+" 执行了。。。。。。。。。");    }    public static void main(String[] args) {        //线程1        Thread t1 = new Thread(() -> {            hello();        });        t1.start();        //线程2        Thread t2 = new Thread(() -> {            hello();        });        t2.start();        try {            t1.join();            t2.join();        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("主函数执行完毕。。。。。。。。。");    }

    结果如下:

    176e27d72ad9059766d213df799fdf69.png

    为什么join(),可以实现线程同步呢?join()源码如下:

    333aa17e221faa56c93f32338ca8c491.png

    很明显,这里使用while做了循环等待,让线程不往下执行,达到线程同步(等待)的效果。

    然而我们平时的开发过程中基本不会这么创建线程,一般都是使用线程池,那在使用线程池的情况下如何让线程实现同步呢?

    我们先试试自己写一个方法让它实现同步,代码如下:

        public static  void hello(){        String name = Thread.currentThread().getName();        try {            System.out.println("线程:"+name+" 休眠开始。。。。。。。。。。。。");            Thread.sleep(1000);            System.out.println("线程:"+name+" 休眠结束。。。。。。。。。。。。");        } catch (InterruptedException e) {            e.printStackTrace();        }    }    public static  void main(String[] args)  {        // 计数器初始化为2        AtomicInteger count = new AtomicInteger(2);        executor.execute(() ->{            hello();            count.decrementAndGet();        });        executor.execute(() ->{            hello();            count.decrementAndGet();        });        //等待两个线程执行完毕        while(count.get() != 0){        }        System.out.println("我是在两个线程执行之后才执行的内容");    }count:用于统计线程执行的数量,线程执行-1;AtomicInteger:原子类,可以在多线程中保证共享变量的安全。decrementAndGet:自减并返回自减以后的结果(原子操作)。while:线程同步的重点:这里主要是让主线程处于循环状态,直到count被减为0,也就意味着两个子线程都已执行完毕。

    但是我不推荐这么做,为什么呢?因为java SDK给我们提供了现成的方法,我们为啥还要自己去手动实现呢?下面我们就来看看 CountDownLatch是如何实现线程同步:

    // 创建2个线程的线程池    private static  Executor executor =   Executors.newFixedThreadPool(2);    public static  void hello(){        String name = Thread.currentThread().getName();        try {            System.out.println("线程:"+name+" 休眠开始。。。。。。。。。。。。");            Thread.sleep(1000);            System.out.println("线程:"+name+" 休眠结束。。。。。。。。。。。。");        } catch (InterruptedException e) {            e.printStackTrace();        }    }    public static  void main(String[] args)  {                //这里需要注意一点,那就是实例化CountDownLatch的初始大小,一定要和你需要等待线程的数量相同,        //小了会导致等待的线程提前执行。        //大了会导致线程一直处于无限循环当中        CountDownLatch countDownLatch = new CountDownLatch(2);        executor.execute(() ->{            hello();            countDownLatch.countDown();        });        executor.execute(() ->{            hello();            countDownLatch.countDown();        });        //等待两个线程执行完毕        try {            countDownLatch.await();        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("我是在两个线程执行之后才执行的内容");    }

    为了效果明显,我特意在hello方法让线程休眠1秒。 countDownLatch:实现线程同步的关键,实例化一个需要等待的线程数量 countDownLatch.countDown():等待线程数-1。 countDownLatch.await();让主线程处于等待状态,直到等待的线程被减为0(注意:这里必须要做异常捕获线程中断的异常:(InterruptedException);

    上面代码结果如下:

    42137b05123d3bdeee2bb04dc63d400d.png

    这里需要注意一点:CountDownLatch的初始大小是不会被重置的,所以使用这个解决方案的时候需要手动重置CountDownLatch线程等待的初始大小。 实现原理:

    4ed619b89261c2aa1b5c68f53d390f54.png

    其实查看源码,他的实现方式和我之前使用的while类似,他这里用了for的无限循环,直到等待的线程被减为0;

    那有没有不需要重新设置线程等待的工具类呢?肯定是有的,那就是接下来要说的:CyclicBarrier

    CyclicBarrier

    主要通过线程回调来实现线程等待,这里的实现方式稍微做了一下修改:

    // 创建3个线程的线程池,其中一个线程用于回调处理主线程的事情    private static  Executor executor =   Executors.newFixedThreadPool(3);    public static  void hello(){        String name = Thread.currentThread().getName();        try {            System.out.println("线程:"+name+" 休眠开始。。。。。。。。。。。。");            Thread.sleep(1000);            System.out.println("线程:"+name+" 休眠结束。。。。。。。。。。。。");        } catch (InterruptedException e) {            e.printStackTrace();        }    }    public static  void main(String[] args)  {        //这里需要注意一点,那就是实例化CountDownLatch的初始大小,一定要和你需要等待线程的数量相同,        //小了会导致等待的线程提前执行。        //大了会导致线程一直处于无限循环当中        final CyclicBarrier barrier = new CyclicBarrier(2, ()->{ executor.execute(()->printAfter()); });        executor.execute(() ->{            hello();            try {                barrier.await();            } catch (Exception e) {                e.printStackTrace();            }        });        executor.execute(() ->{            hello();            try {                barrier.await();            } catch (Exception e) {                e.printStackTrace();            }        });    }    /**     * 两个线程执行完毕之后执行此方法     */    private static void printAfter() {        System.out.println("我是在两个线程执行之后才执行的内容");    }
    72774ef00382366a2fa3eee11dba6480.png

    这里需要注意一点,那就是主函数的输出语句已经不放在mian方法中了,而是写在了barrier的回调方法中。当等待的线程执行完毕之后CyclicBarrier的等待线程数会被重置。

    CyclicBarrier与CountDownLatch区别 CountDownLatch:解决一个线程等待多个线程场景。 CyclicBarrier:解决一组线程之间的等待场景。 CyclicBarrier支持重置功能,CountDownLatch不支持,这点需要特别注意。

    展开全文
  • 线程同步可以说在日常开发中是用的很,但对于其内部如何实现的,一般人可能知道的并不。本篇文章将从如何实现简单的锁开始,介绍linux中的锁实现futex的优点及原理,最后分析java中同步机制如wait/notify, ...
  • 线程同步可以说在日常开发中是用的很,但对于其内部如何实现的,一般人可能知道的并不。本篇文章将从如何实现简单的锁开始,介绍linux中的锁实现futex的优点及原理,最后分析java中同步机制如wait/notify, ...
  • 本文主要讲多线程的线程之间的资源共享怎么保持同步多线程基础篇见,木头人:Python threading实现多线程 基础篇Python的多线程,只有用于I/O密集型程序时效率才会有明显的提高,如文件/输入输出/socket网络通信/...
  • 多线程之间实现同步

    2020-03-03 19:36:20
    线程共享一个全局变量或静态变量时,做写的操作可能会产生数据不一致,做读的操作不受影响。 二、线程安全问题怎么解决?(使用同步或使用锁) 1.使用synchronized 同步代码块, 1.1、synchronized关键字包括...
  • 涉及到多线程同步的问题 具体的过程可以抽象为这样(线程A和B都不是主线程,是主线程开启的) 线程A 获取事物C的坐标变量M 这个坐标第一次设置为0 即M(初始)=0 (后面设置为从线程B中处理后的数据。)事物A先...
  • python多线程使用lock实现同步

    千次阅读 2018-04-04 13:02:33
    一直在想,python和java的synchronized等价的是什么,怎么实现同步呢? 为了测试同步,我们用5个线程同时进行累加,每次加1进行1000000次。 如果同步成功,那么结果是5000000。 我们分别用正确的lock加锁方式,不...
  • 本文主要讲述了操作系统中同步和互斥这两个概念,并说明了操作系统中是如何实现同步和互斥的。除此之外,本文还重点讲述了线程和进程的概念。
  • DiskFileItemFactory factory = new DiskFileItemFactory();//磁盘缓存 ServletFileUpload upload = new ServletFileUpload(factory);//创建一个文件上传处理器 upload.setFileSizeMax...我这里没有写线程,求指点
  • 线程同步

    2020-04-06 12:07:50
    天猫精灵:小爱同学 ...多线程处理可以用 Condition 是实现条件变量的类 完成复杂的线程同步 怎么实现的? import threading class XiaoAi(threading.Thread): def __init__(self,cond): super().__...
  • 即当两个及两个以上的线程同时访问共享资源时,如果此时没有预设对应的同步机制,就可能带来同一时刻线程同时访问同一个共享资源,即出现竞态,多数情况下我们是不希望出现这样的情况的,那么怎么避免呢?...
  • 同步和异步同步和异步用请求返回调用的方式来理解相对简单。 同步:可以理解为发出一个请求后,必须等待返回结果才能执行后续的操作。 异步:请求发出后,不需要等待返回结果,可以继续执行后续操作,异步...
  • 在C++11标准库中实现了线程的重要基本设施,使用这些功能轻松构建复杂的多线程程序,但是比起微软或者第三库功能还是不怎么全面,比如读写锁就没有实现,但是可以利用已有的功能,轻松实现一个读写锁。代码如下: #...
  • 现实信号量关键是 p v 操作,由于p v 操作是不可中断的,怎么模拟使得 p v 操作不可中断的执行呢?
  • 1、并行、多线程(Parallel、Task、ThreadPool)2、多进程MultipleProcess恰好工作中又一次遇到单线程程序性能低的问题,本次我主要想尝试使用ThreadPool来实现多线程,并且在实现多线程任务同步结束。...
  • 线程同步通信技术:多线程之间要实现数据同步。通过通信实现同步。那么怎么实现呢? 看一个问题: 有两个线程,子线程先执行10次,然后主线程执行5次,然后再切换到子线程执行10,再主线程执行5次……如此往返执行50...
  • 线程同步事件等待句柄   通过通知操作的方式来....NET中线程同步的方式的让人看了眼花缭乱,究竟该怎么去理解呢?其实,我们抛开.NET环境看线程同步,无非是执行两种操作:一是互斥/加锁,目的是保证临界区代...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 607
精华内容 242
关键字:

多线程同步怎么实现