java高并发synchronized学习

1.synchronized的作用：同步方法支持一种简单的策略来防止线程干扰和内存一致性的错误：如果一个对象对多个线程可见，则对该对象的所有读取或写入都是通过同步方法来完成的。总的来说是能够在同一时候保证最多只有一个线程执行该段代码，以达到安全的效果。

2.synchronized是java的关键字，被java语言原生支持，是最基本的互斥同步手段

代码演示

public class DisapperRequest1 implements  Runnable {    static int k=0;    static DisapperRequest1 disapperRequest1=new DisapperRequest1();    @Override    public void run() {       for(int i=0;i<100000;i++)       {           k++;       }    }

    public static void main(String[] args) throws InterruptedException {          Thread thread=new Thread(disapperRequest1);          Thread thread1=new Thread(disapperRequest1);          thread.start();          thread1.start();

  /**join的意思是使得放弃当前线程的执行，并返回对应的线程，例如下面代码的意思就是：程序在main线程中调用t1线程的join方法，则main线程放弃cpu控制权，并返回t1线程继续执行直到线程t1执行完毕所以结果是t1线程执行完后，才到主线程执行，相当于在main线程中同步t1线程，t1执行完了，main线程才有执行的机会

          thread.join();          thread1.join();          System.out.println(k);    }

}join方法是通过调用线程的wait方法来达到同步的目的的。例如，A线程中调用了B线程的join方法，则相当于A线程调用了B线程的wait方法，在调用了B线程的wait方法后，A线程就会进入阻塞状态最后的结果总是小于或等于20W 这跟预期的结果不一样。count++看上去只有一个操作，实际上是有三个操作的1.读取count的值 2.讲count加1 3.将count的值加入内存

当count的值还没有加入内存的时候count就已经读取了。这样就会造成线程不安全。

3.Synchronized两种方法用法：对象锁：包括方法锁（默认锁对象为this当前的实例的对象）和同步代码块锁（自己指定锁对象）。类锁：指的是用Synchronized修饰的静态方法或者指定锁对象为class对象代码块形式要手动指定对象，方发锁形式：Synchronized修饰普通方法，锁对象默认为this

代码块锁：isAlive方法判断线程是否存活

public class SynchronizedObjectCodeBlock2 implements Runnable {static SynchronizedObjectCodeBlock2 instance=new SynchronizedObjectCodeBlock2();@Overridepublic void run() {synchronized(this) {System.out.println(Thread.currentThread().getName());try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "运行结束");}}public static void main(String[] args) {Thread t1=new Thread(instance);Thread t2=new Thread(instance);t1.start();t2.start();while (t1.isAlive()||t2.isAlive()){}System.out.println("结束");}
}

当用两个锁的情况：当不是同一把锁的时候，可以并行运行

public class SynchronizedObjectCodeBlock2 implements Runnable {static SynchronizedObjectCodeBlock2 instance=new SynchronizedObjectCodeBlock2();Object lock1=new Object();Object lock2=new Object();@Overridepublic void run() {synchronized(lock1) {System.out.println(Thread.currentThread().getName()+"lock1");try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "运行结束1");}synchronized(lock2) {System.out.println(Thread.currentThread().getName()+"lock2");try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "运行结束2");}}public static void main(String[] args) {Thread t1=new Thread(instance);Thread t2=new Thread(instance);t1.start();t2.start();while (t1.isAlive()||t2.isAlive()){}System.out.println("结束");}
}

对象锁：Synchronized修饰普通的方法，默认锁对象为this

package com.xiaoqiang.sychronized;public class SynchronizedObjectMethod3 implements Runnable {static SynchronizedObjectMethod3 instance=new SynchronizedObjectMethod3();@Overridepublic void run() {method();}public static void main(String[] args) {Thread t1=new Thread(instance);Thread t2=new Thread(instance);t1.start();t2.start();while (t1.isAlive()||t2.isAlive()){}System.out.println("结束");}public synchronized  void method(){System.out.println(Thread.currentThread().getName()+"lock1");try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "运行结束1");}
}

类锁：

1.staic 类锁：假如不在method中加入staic修饰的话，两个不同的静态对象就会并行执行run方法

package com.xiaoqiang.sychronized;public class SynchronizedClassStatic4 implements  Runnable {static  SynchronizedClassStatic4 instance1=new SynchronizedClassStatic4();static SynchronizedClassStatic4 instance2=new SynchronizedClassStatic4();@Overridepublic void run() {method();}public static void main(String[] args) {Thread t1=new Thread(instance1);Thread t2=new Thread(instance2);t1.start();t2.start();while (t1.isAlive()||t2.isAlive()){}System.out.println("结束");}public synchronized  void method(){System.out.println(Thread.currentThread().getName()+"lock1");try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "运行结束1");}
}

如果用 static 修饰method方法的话就会串行进行

package com.xiaoqiang.sychronized;public class SynchronizedClassStatic4 implements  Runnable {static  SynchronizedClassStatic4 instance1=new SynchronizedClassStatic4();static SynchronizedClassStatic4 instance2=new SynchronizedClassStatic4();@Overridepublic void run() {method();}public static void main(String[] args) {Thread t1=new Thread(instance1);Thread t2=new Thread(instance2);t1.start();t2.start();while (t1.isAlive()||t2.isAlive()){}System.out.println("结束");}public  static synchronized  void method(){System.out.println(Thread.currentThread().getName()+"lock1");try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "运行结束1");}
}

2.。*.class 类锁同一个类锁的实现

package com.xiaoqiang.sychronized;public class SynchronizedClassClass5 implements Runnable {static  SynchronizedClassClass5 instance1=new SynchronizedClassClass5();static SynchronizedClassClass5 instance2=new SynchronizedClassClass5();@Overridepublic void run() {method();}public static void main(String[] args) {Thread t1=new Thread(instance1);Thread t2=new Thread(instance2);t1.start();t2.start();while (t1.isAlive()||t2.isAlive()){}System.out.println("结束");}private  void method() {synchronized (SynchronizedClassClass5.class) {System.out.println(Thread.currentThread().getName() + "lock1");try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "运行结束1");}}
}

4.Synchronized的核心思想：

1.一把锁只能同时被一个线程获取，没有拿到锁的线程必须等待。

2.每个实例都对应自己的一把锁，不同实例之间互不影响。例外：锁对象是*.class或者用Synchronized修饰的是static方法时，所有对象都共用同一把锁

3.无论是正常运完毕或者方法抛出异常，都会释放锁。

5.Synchronized的性质

1.可重入性：指的是同一线程外层函数获取到锁后之后，内层函数可以直接再次获取该锁。

好处：避免死锁，提高封装性。

粒度（范围）:线程而非调用

2.不可中断性：一旦这个锁已经被别人获得了，如果我还想获得，就必须等待或者阻塞，直到别的线程释放这个锁。如果别人永远不释放锁，那么只能永远的等待下去。

6.Synchronized的缺点：

效率低：锁的释放情况少，试图获得锁的时候不能设置超时，不能中断一个正试图获得锁的线程。

不够灵活：加锁和释放锁的时机单一，每个锁仅有单一的条件，可能是不够的。

无法知道是否成功获取到锁

转载于:https://www.cnblogs.com/socketqiang/p/10819208.html

java高并发synchronized学习相关推荐

Java高并发编程学习（三）java.util.concurrent包
简介我们已经学习了形成Java并发程序设计基础的底层构建块,但对于实际编程来说,应该尽可能远离底层结构.使用由并发处理的专业人士实现的较高层次的结构要方便得多.要安全得多.例如,对于许多线程问题,可 ...
Java高并发程序设计学习笔记（十一）：Jetty分析
转自:https://blog.csdn.net/dataiyangu/article/details/87894253 new Server() 初始化线程池 QueuedThreadPool ex ...
Java高并发程序设计学习笔记（五）：JDK并发包(各种同步控制工具的使用、并发容器及典型源码分析（Hashmap等）)...
转自:https://blog.csdn.net/dataiyangu/article/details/86491786#2__696 1. 各种同步控制工具的使用 1.1. ReentrantLoc ...
cpu高 thread vm_阿里大佬总结，Java高并发必读!
作者:wxdoop 原文:https://blog.csdn.net/qq_36235098 来源:前程有光前言进程是计算机中程序关于某几何数据集合上的一次运行活动,是系统进行资源分配和调度的基本 ...
libevent c++高并发网络编程_高并发编程学习(2)——线程通信详解
前序文章高并发编程学习(1)--并发基础 - https://www.wmyskxz.com/2019/11/26/gao-bing-fa-bian-cheng-xue-xi-1-bing-fa-j ...
Java高并发编程详解系列-Java线程入门
根据自己学的知识加上从各个网站上收集的资料分享一下关于java高并发编程的知识点.对于代码示例会以Maven工程的形式分享到个人的GitHub上面. 首先介绍一下这个系列的东西是什么,这个系列自己 ...
Java高并发程序设计（三）——JDK并发包（二）
引言好久没来学习Java高并发程序设计了,感觉在慢慢遗忘之前学过的内容,今天打算重新拾起. Condition Condition与前两章讲的Object.wait() 和Object.notify ...
高并发编程学习(2)——线程通信详解
前序文章高并发编程学习(1)--并发基础 - https://www.wmyskxz.com/2019/11/26/gao-bing-fa-bian-cheng-xue-xi-1-bing-fa-j ...
Java 高并发系列1-开篇
Java 高并发系列1-开篇我们都知道在Android开发中, 一个Android程序启动之后会有一个主线程,也就是UI线程, 而网络加载数据, 本地文件长时间读写,图片压缩,等等,很多耗时操作会阻 ...

java高并发synchronized学习

java高并发synchronized学习相关推荐

最新文章

热门文章