18.synchronized

同步的前提：

必须要有两个或者两个以上的线程
必须是多个线程使用同一个锁
必须保证同步中只能有一个线程在运行

好处：解决了多线程的安全问题
弊端：多个线程需要判断锁，较为消耗资源、抢锁的资源。

import java.util.ArrayList;

import java.util.List;

/**

 * synchronized 实现线程间的同步，对同步的代码加锁，似的每次只能有一个线程进入同步块

 * 可以保证线程间的可见性和有序性

 * · 指定加锁对象：对给定对象加锁，进入同步代码前要获取给定对象的锁

 * · 直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获取当前实例的锁

 * · 直接作用于静态方法：相当于对当前类加锁，进入同步代码前要获取当前类的锁 -- class文件

 */

public class SynchronizedDemo {

    private static int size = 0;

    private static List<Integer> arrayOne = new ArrayList<>(10000);

    private static List<Integer> arrayTwo = new ArrayList<>(10000);

    public static synchronized void increase(){ //synchronized作用于一个实例方法

        size++;

    }

    public static void main(String[] args) throws InterruptedException{

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

            arrayOne.add(0);

            arrayTwo.add(0);

        }

        Thread threadOne = new Thread(() -> {

            int length = arrayOne.size();

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

                if (arrayOne.get(i).intValue()==0){

                    increase();

                }

            }

        });

        Thread threadTwo = new Thread(() -> {

            int length = arrayTwo.size();

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

                if (arrayTwo.get(i).intValue()==0){

                    increase();

                }

            }

        });

        threadOne.start();

        threadTwo.start();

        threadOne.join();

        threadTwo.join();

        System.out.println(size);

    }

}

import java.util.ArrayList;

import java.util.List;

/**

 * Runnable

 */

public class SynchronizedDemo1 {

    private static int size = 0;

    private static List<Integer> arrayOne = new ArrayList<>(10000);

    private static List<Integer> arrayTwo = new ArrayList<>(10000);

    public static class AccountSyncBad implements Runnable{

        synchronized void increase(){ //synchronized

            size++;

        }

        @Override

        public void run() {

            int length = arrayOne.size();

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

                if (arrayOne.get(i).intValue()==0){

                    increase();

                }

            }

        }

    }

    public static void main(String[] args) throws InterruptedException{

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

            arrayOne.add(0);

            arrayTwo.add(0);

        }

        AccountSyncBad accountSyncBad = new AccountSyncBad();

        Thread threadOne = new Thread(accountSyncBad);

        Thread threadTwo = new Thread(accountSyncBad);

        threadOne.start();

        threadTwo.start();

        threadOne.join();

        threadTwo.join();

        System.out.println(size);

    }

}

import java.util.ArrayList;

import java.util.List;

/**

 * 两个线程指向不同的Runnable实例，这两个线程使用的是两把不同的锁，无法保证线程安全

 */

public class SynchronizedDemo2 {

    private static int size = 0;

    private static List<Integer> arrayOne = new ArrayList<>(10000);

    private static List<Integer> arrayTwo = new ArrayList<>(10000);

    public static class AccountSyncBad implements Runnable{

        synchronized void increase(){ //synchronized

            size++;

        }

//        static synchronized void increase(){ //修改为static，这样即使两个线程指向不同的Runnable，但请求的是当前类的锁，因此可以正确同步

//            size++;

//        }

        @Override

        public void run() {

            int length = arrayOne.size();

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

                if (arrayOne.get(i).intValue()==0){

                    increase();

                }

            }

        }

    }

    public static void main(String[] args) throws InterruptedException{

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

            arrayOne.add(0);

            arrayTwo.add(0);

        }

        Thread threadOne = new Thread(new AccountSyncBad());

        Thread threadTwo = new Thread(new AccountSyncBad());

        threadOne.start();

        threadTwo.start();

        threadOne.join();

        threadTwo.join();

        System.out.println(size);

    }

}

巴特西

18.synchronized

同步的前提：

最新文章

热门文章