修饰类
package com.lyy.concurrency.sync; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class SynchronizedExample2 { // 修饰一个类 public static void test1(int j){ synchronized (SynchronizedExample2.class){ for (int i = 0; i < 10; i++) { System.out.println("test1 j："+j+" — i："+i); } } } public static void main(String[] args) { SynchronizedExample2 example1 = new SynchronizedExample2(); SynchronizedExample2 example2 = new SynchronizedExample2(); ExecutorService executorService = Executors.newCachedThreadPool();//声明一个线程池 //加上线程池相当于我们调用了两个线程 l //两个线程调用了同一个对象 executorService.execute(() ->{ example1.test1(1); }); executorService.execute(() ->{ example2.test1(2); }); } }
返回结果：
test1 j：1 — i：0 test1 j：1 — i：1 test1 j：1 — i：2 test1 j：1 — i：3 test1 j：1 — i：4 test1 j：1 — i：5 test1 j：1 — i：6 test1 j：1 — i：7 test1 j：1 — i：8 test1 j：1 — i：9 test1 j：2 — i：0 test1 j：2 — i：1 test1 j：2 — i：2 test1 j：2 — i：3 test1 j：2 — i：4 test1 j：2 — i：5 test1 j：2 — i：6 test1 j：2 — i：7 test1 j：2 — i：8 test1 j：2 — i：9
修饰静态方法：
package com.lyy.concurrency.sync; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class SynchronizedExample2 { //修饰一个静态方法 public static synchronized void test2(int j){ for (int i = 0; i < 10; i++) { System.out.println("test2 j："+j+" — i："+i); } } public static void main(String[] args) { SynchronizedExample2 example1 = new SynchronizedExample2(); SynchronizedExample2 example2 = new SynchronizedExample2(); ExecutorService executorService = Executors.newCachedThreadPool();//声明一个线程池 //加上线程池相当于我们调用了两个线程 l //两个线程调用了同一个对象 executorService.execute(() ->{ example1.test2(1); }); executorService.execute(() ->{ example2.test2(2); }); } }
返回结果：
test2 j：1 — i：0 test2 j：1 — i：1 test2 j：1 — i：2 test2 j：1 — i：3 test2 j：1 — i：4 test2 j：1 — i：5 test2 j：1 — i：6 test2 j：1 — i：7 test2 j：1 — i：8 test2 j：1 — i：9 test2 j：2 — i：0 test2 j：2 — i：1 test2 j：2 — i：2 test2 j：2 — i：3 test2 j：2 — i：4 test2 j：2 — i：5 test2 j：2 — i：6 test2 j：2 — i：7 test2 j：2 — i：8 test2 j：2 — i：9
案例：
线程不安全案例：
package com.lyy.concurrency.example.count; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Semaphore; public class CountExample1 { //请求总数 public static int clientTotal = 5000; //同时并发执行的线程数 public static int threadTotal = 200; // public static int count = 0; public static void main(String[] args) throws Exception{ ExecutorService executorService = Executors.newCachedThreadPool();//线程池 final Semaphore semaphore = new Semaphore(threadTotal);//允许并发的数量 final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); for (int i = 0; i < clientTotal; i++) { executorService.execute(() ->{ try { semaphore.acquire();//判断线程是否允许被执行 add();//当acquire()返回出来值之后才会被执行 semaphore.release(); } catch (InterruptedException e) { e.printStackTrace(); } countDownLatch.countDown(); }); } countDownLatch.await(); executorService.shutdown(); System.out.println("count："+count); } private static void add(){ count++; } }
执行结果：
count：4973 • 1
我们看到执行结果是4973，而正确的执行结果应该是5000，那么我们怎么才能让结果显示为5000呢，就看接下来我们使用synchronized实现一个线程安全的类
线程安全的类:
package com.lyy.concurrency.example.count; import com.lyy.concurrency.annoatioons.NotThreadSafe; import com.lyy.concurrency.annoatioons.ThreadSafe; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Semaphore; @Slf4j @ThreadSafe //线程安全的类 public class CountExample3 { //请求总数 public static int clientTotal = 5000; //同时并发执行的线程数 public static int threadTotal = 200; // public static int count = 0; public static void main(String[] args) throws Exception{ ExecutorService executorService = Executors.newCachedThreadPool();//线程池 final Semaphore semaphore = new Semaphore(threadTotal);//允许并发的数量 final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); for (int i = 0; i < clientTotal; i++) { executorService.execute(() ->{ try { semaphore.acquire();//判断线程是否允许被执行 add();//当acquire()返回出来值之后才会被执行 semaphore.release(); } catch (InterruptedException e) { e.printStackTrace(); } countDownLatch.countDown(); }); } countDownLatch.await(); executorService.shutdown(); System.out.println("count："+count); } private synchronized static void add(){ count++; } }
返回结果：
count：5000
总结：
1、synchronized：是不可中断锁，适合竞争不激烈，可读性比较好
2、无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；
3、如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。
4、每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
5、实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
