synchronized关键字

synchronized关键字

synchronsized有三种应用方式：synchronized作用于实例方法，sychronized作用于静态方法，synchronized同步代码块 造成线程安全问题的原因，有共享数据，多个线程操作共享数据。 解决方式，保证同一时刻只有一个线程操作数据，其他线程必须在线程处理完成之后在进行，访问互斥 synchronized保证统一时刻只有一个线程可以执行某个方法或者某个代码块中的共享数据进行操作，synchronized保证一个线程导致共享数据的变化能够被其他线程看到，保证可见性，完全可以替代volatile功能 修饰实例方法，作用于当前实例加锁，进入同步代码前要首先获得当前实例的锁 修饰静态方法，作用于当前类对象加锁，进入同步方法之前首先要获取当前类对象的锁，这种用类对象加锁的方式实际上为了解决多个实例对象加锁的情况下带来的线程不安全的情况 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码块前要获得给定对象的锁 synchronized作用于实例方法 实例对象锁作用于实例方法就是用synchronized修饰实例对象中的实例方法，注意修饰的是实例方法，而不是静态方法，什么是实例方法：类中没有静态关键字修饰的方法，想使用实例方法就要先创建一个实例对象，通过创建的实例对象调用这个实例方法，静态方法就是直接通过类名就可以调用类中声明的实例方法

下面分别看下代码的实现

ASynchronized：

package com.liu.demo05; /** * @outhor liu * @dare 2020/7/4 0:42 */ public class ASynchronized { public static void main(String[] args) { final ASynchronized aSynchronized = new ASynchronized(); new Thread(new Runnable() { @Override public void run() { aSynchronized.aThread(); } }).start(); new Thread(new Runnable() { @Override public void run() { aSynchronized.bThread(); } }).start(); } //同步方法-----锁住的是对象 public synchronized void aThread(){ for (int i = 0; i <5 ; i++) { System.out.println("aThread----->"+i); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } } public synchronized void bThread(){ for (int i = 0; i <5 ; i++) { System.out.println("bThread------->"+i); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } } }

输出：

aThread----->0 aThread----->1 aThread----->2 aThread----->3 aThread----->4 bThread------->0 bThread------->1 bThread------->2 bThread------->3 bThread------->4

实例方法-并发 BSynchronized：

package com.liu.demo05; /** * @outhor liu * @dare 2020/7/4 0:51 */ public class BSynchronized { public static void main(String[] args) { final BSynchronized bSynchronized = new BSynchronized(); final BSynchronized bSynchronized1 = new BSynchronized(); new Thread(new Runnable() { @Override public void run() { bSynchronized.aThread(); } }).start(); new Thread(new Runnable() { @Override public void run() { bSynchronized1.bThread(); } }).start(); } //同步方法-----锁住的是对象 public synchronized void aThread(){ for (int i = 0; i <5 ; i++) { System.out.println("aThread----->"+i); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } } public synchronized void bThread(){ for (int i = 0; i <5 ; i++) { System.out.println("bThread------->"+i); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } } }

输出：

aThread----->0 bThread------->0 aThread----->1 bThread------->1 aThread----->2 bThread------->2 aThread----->3 bThread------->3 aThread----->4 bThread------->4

静态方法：

CSynchronized：

package com.liu.demo05; /** * @outhor liu * @dare 2020/7/4 0:58 */ public class CSynchronized { public static void main(String[] args) { final CSynchronized cSynchronized = new CSynchronized(); final CSynchronized cSynchronized1 = new CSynchronized(); new Thread(new Runnable() { @Override public void run() { cSynchronized.aThread(); } }).start(); new Thread(new Runnable() { @Override public void run() { cSynchronized1.bThread(); } }).start(); } //静态方法 public static synchronized void aThread(){ for (int i = 0; i <5 ; i++) { System.out.println("aThread------------>"+i); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } } public static synchronized void bThread(){ for (int i = 0; i < 5; i++) { System.out.println("bThread----------->"+i); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } } }

输出：

aThread------------>0 aThread------------>1 aThread------------>2 aThread------------>3 aThread------------>4 bThread----------->0 bThread----------->1 bThread----------->2 bThread----------->3 bThread----------->4

代码块：

DSynchronized：

package com.liu.demo05; /** * @outhor liu * @dare 2020/7/4 1:06 */ public class DSynchronized { String locka = "locka"; public static void main(String[] args) { final DSynchronized dSynchronized = new DSynchronized(); new Thread(new Runnable() { @Override public void run() { dSynchronized.aMathod(); } }).start(); new Thread(new Runnable() { @Override public void run() { dSynchronized.bMathod(); } }).start(); } public void aMathod(){ synchronized (locka){ for (int i = 0; i <3 ; i++) { try { Thread.sleep(3000); System.out.println("aMathod---------->"+i); } catch (InterruptedException e) { e.printStackTrace(); } } } } public void bMathod(){ synchronized (locka){ for (int i = 0; i < 3; i++) { for (int j = 0; j < 3 ; j++) { System.out.println("bMathod------>"+j); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } } } } }

输出：

aMathod---------->0 aMathod---------->1 aMathod---------->2 bMathod------>0 bMathod------>1 bMathod------>2

喜欢的朋友关注我微信公众号哦，每天都有干货分享