Java同步关键字

最新推荐文章于 2023-06-14 12:13:17 发布
最新推荐文章于 2023-06-14 12:13:17 发布
阅读量1k 收藏
点赞数
分类专栏： Java基础 文章标签： java 同步 Lock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mrbcy/article/details/54799313
版权

Java同步关键字

synchronized

如果代码中有一段代码被synchronized代码块包含起来了，那么线程中的run()方法执行到这段代码时，其他线程不能执行这段代码。

用一段代码同时只能由一个线程执行。

sample

package com.mrbcy.bigdata.basic.thread.testthread;

public class MySynchronized {
    public static void main(String[] args) {
        final MySynchronized mySynchronized1 = new MySynchronized();
        final MySynchronized mySynchronized2 = new MySynchronized();

        new Thread("thread1"){

            @Override
            public void run() {
                // TODO Auto-generated method stub
                super.run();
                synchronized (mySynchronized1) {
                    System.out.println(this.getName() + " start working...");
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(this.getName() + " finish work");
                }
            }

        }.start();

        new Thread("thread2"){
            @Override
            public void run() {
                // TODO Auto-generated method stub
                super.run();

                synchronized (mySynchronized1) {
                    System.out.println(this.getName() + " start working...");

                }
            }
        }.start();
    }

}

输出结果如下：

thread1 start working...
thread1 finish work
thread2 start working...

这是因为我们在两个线程的synchronized块中指定对象时都使用了mySynchronized1，此时只能有一个线程同时进入synchronized块。如果它们指定对象不同，则两线程可以同时运行。下面我们来验证这一点。

把Thread2中的synchronized对象改成mySynchronized2。

new Thread("thread2"){
    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();

        synchronized (mySynchronized2) {
            System.out.println(this.getName() + " start working...");

        }
    }
}.start();

输出结果如下：

thread1 start working...
thread2 start working...
thread1 finish work

synchronized还可以直接修饰一个方法。

synchronized缺陷

如果一个获得锁的线程一直不退出，其他的线程都无法获得锁，会阻塞所有的其他线程。但是如果获得锁的线程发生异常，jvm会把锁释放掉。

Lock

lock可以实现在无法获取锁时无需阻塞等待，去做其他事。

Lock api示例

简单的lock和tryLock

package com.mrbcy.bigdata.basic.thread.lock;

import java.util.ArrayList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


public class MyLockTest {
    static Lock lock = new ReentrantLock();
    private static ArrayList<Integer> arrayList = new ArrayList<Integer>();
    public static void main(String[] args) {
        new Thread("thread1"){

            @Override
            public void run() {
                // TODO Auto-generated method stub
                super.run();
                lock.lock();
                try{
                    System.out.println(this.getName() + "得到了锁");
                    for(int i = 0; i < 5; i++){
                        arrayList.add(i);
                    }
                }catch (Exception e) {
                    // TODO: handle exception
                }finally{
                    System.out.println(this.getName() + "释放了锁");

                }
            }

        }.start();

        new Thread("thread2"){
            @Override
            public void run() {
                // TODO Auto-generated method stub
                super.run();
                boolean lockResult = lock.tryLock();
                if(lockResult){
                    try{
                        System.out.println(this.getName() + "得到了锁");
                        for(int i = 0; i < 5; i++){
                            arrayList.add(i);
                        }
                    }catch (Exception e) {
                        // TODO: handle exception
                    }finally{
                        System.out.println(this.getName() + "释放了锁");

                    }
                }
            }
        }.start();
    }
}

lockInterruptibly的使用示例。
package com.mrbcy.bigdata.basic.thread.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 观察现象：如果thread-0得到了锁，阻塞。。。thread-1尝试获取锁，如果拿不到，则可以被中断等待
 * @author
 *
 */
public class MyInterruptibly {
     private Lock lock = new ReentrantLock();  

        public static void main(String[] args)  {
            MyInterruptibly test = new MyInterruptibly();
            MyThread thread0 = new MyThread(test);
            MyThread thread1 = new MyThread(test);
            thread0.start();
            thread1.start();

            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            thread1.interrupt();
            System.out.println("=====================");
        }  

        public void insert(Thread thread) throws InterruptedException{
            lock.lockInterruptibly();   //注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将InterruptedException抛出
            try {  
                System.out.println(thread.getName()+"得到了锁");
                long startTime = System.currentTimeMillis();
                for(    ;     ;) {
                    if(System.currentTimeMillis() - startTime >= Integer.MAX_VALUE)
                        break;
                    //插入数据
                }
            }
            finally {
                System.out.println(Thread.currentThread().getName()+"执行finally");
                lock.unlock();
                System.out.println(thread.getName()+"释放了锁");
            }  
        }
    }

    class MyThread extends Thread {
        private MyInterruptibly test = null;
        public MyThread(MyInterruptibly test) {
            this.test = test;
        }
        @Override
        public void run() {

            try {
                test.insert(Thread.currentThread());
            } catch (Exception e) {
                System.out.println(Thread.currentThread().getName()+"被中断");
            }
        }

}

稍微说明一下，两个线程都是用lock.lockInterruptibly()来获取锁，如果有的线程没有获取到锁，可以调用interrupt方法中断它，它就可以继续做别的事了。注意被中断的线程会抛出一个异常

ReadWriteLock

对于数据来说，多个线程同时读不会产生影响。

ReadWriteLock是一个接口。利用它可以实现分别的获取读锁或写锁来提高应用的性能。

如果一组线程中没有线程拿到写锁，所有的线程都可以读。如果有一个线程拿到了写锁，所有的其他线程都不能读也不能写了。

ReadWriteLock 示例

用synchronized来实现的代码示例

package com.mrbcy.bigdata.basic.thread.lock;


/**
 * 一个线程又要读又要写，用synchronize来实现的话，读写操作都只能锁住后一个线程一个线程地进行
 * @author
 *
 */
public class MySynchronizedReadWrite {

    public static void main(String[] args)  {
        final MySynchronizedReadWrite test = new MySynchronizedReadWrite();

        new Thread(){
            public void run() {
                test.get(Thread.currentThread());
            };
        }.start();

        new Thread(){
            public void run() {
                test.get(Thread.currentThread());
            };
        }.start();

    }  

    public synchronized void get(Thread thread) {
        long start = System.currentTimeMillis();
        int i=0;
        while(System.currentTimeMillis() - start <= 1) {
            i++;
            if(i%4==0){
            System.out.println(thread.getName()+"正在进行写操作");
            }else {
                System.out.println(thread.getName()+"正在进行读操作"); 
            }
        }
        System.out.println(thread.getName()+"读写操作完毕");
    }

}

使用synchronized时读写只能一起锁定，其他线程只能等待。

使用ReadWriteLock实现的代码示例：
package com.mrbcy.bigdata.basic.thread.lock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 使用读写锁，可以实现读写分离锁定，读操作并发进行，写操作锁定单个线程
 * 
 * 如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。
 * 如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。
 * @author
 *
 */
public class MyReentrantReadWriteLock {
     private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

        public static void main(String[] args)  {
            final MyReentrantReadWriteLock test = new MyReentrantReadWriteLock();

            new Thread(){
                public void run() {
                    test.get(Thread.currentThread());
                    test.write(Thread.currentThread());
                };
            }.start();

            new Thread(){
                public void run() {
                    test.get(Thread.currentThread());
                    test.write(Thread.currentThread());
                };
            }.start();

        }  

        /**
         * 读操作,用读锁来锁定
         * @param thread
         */
        public void get(Thread thread) {
            rwl.readLock().lock();
            try {
                long start = System.currentTimeMillis();

                while(System.currentTimeMillis() - start <= 1) {
                    System.out.println(thread.getName()+"正在进行读操作");
                }
                System.out.println(thread.getName()+"读操作完毕");
            } finally {
                rwl.readLock().unlock();
            }
        }

        /**
         * 写操作，用写锁来锁定
         * @param thread
         */
        public void write(Thread thread) {
            rwl.writeLock().lock();;
            try {
                long start = System.currentTimeMillis();

                while(System.currentTimeMillis() - start <= 1) {
                    System.out.println(thread.getName()+"正在进行写操作");
                }
                System.out.println(thread.getName()+"写操作完毕");
            } finally {
                rwl.writeLock().unlock();
            }
        }
}

使用读写锁，读可以并行执行。如果有其他线程申请了读锁，有线程想申请写锁，它必须等待。如果有个线程已经申请了写锁，所有申请读锁的线程必须等待。

Lock和synchronized的区别

  1. Lock不是Java的关键字，是java.util.concurrent.locks包下的一个接口。
  2. synchronized不需要用户手动的释放锁。Lock必须手动释放锁。
  3. Lock可以实现读写锁分离，在某些场景下可以提高效率。
  4. Lock可以中断等待的线程，在某些场景下可以提高效率。
  5. 通过Lock可以知道是否拿到了锁。

从性能上说，如果资源竞争不是很激烈，两者性能相仿。如果资源竞争很激烈，Lock的性能显著高于synchronized。

墨染百城
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简单了解Java synchronized关键字同步
08-25
Java synchronized关键字同步详解 Java 中的 synchronized 关键字是用于实现线程同步的重要机制。下面我们将详细介绍 synchronized 关键字的使用方法和原理。 synchronized 关键字的作用 synchronized 关键字可以...
Java Volatile关键字同步机制详解
08-19
Java Volatile关键字同步机制详解 Java Volatile关键字是Java语言中的一种同步机制，它可以保证在多线程环境下变量的可见性和原子性。通过使用Volatile关键字，可以确保在多线程环境下对变量的修改是可见的，并且...
Java线程的同步机制(synchronized关键字)
最新发布
豆恭梓的博客
06-14 887
join底层调用的是wait()，而wait是Object的方法，wait本身是会释放锁（彻底交出CPU的执行权），所以 Thread 的join() 方法是否会释放锁？但是，join()只会释放Thread的锁，不会释放线程对象的锁（可能会造成死锁）。●线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程。●线程执行同步代码块或同步方法时，程序调用Thread.sleep()、●当前线程在同步代码块、同步方法中执行了线程对象的。●当前线程的同步方法、同步代码块执行结束。
java中synchronized关键字
龙空白白的博客
06-10 3985
synchronized是java中的一个关键字，在中文中为同步，也被称之为’同步锁’,以此来达到多线程并发访问时候的并发安全问题，可以用来修饰代码块、非静态方法。静态方法等； 修饰代码块时:给当前指定的对象加锁 修饰非静态方法时:作用于当前实例加锁 修饰静态方法时:作用于当前类对象加锁 synchronized在java内存模型中的主要作用 原子性:通过monitorenter和monitorexit指令,保证被synchronized修饰的代码在同一时间只能被一个线程访问，在锁未释放之前，无法被其他线程
【速看】一文清明讲明白线程同步关键字synchronized
唐欢
03-27 476
synchronized 关键字是java的保留字，synchronized 关键字保障了原子性、可见性和有序性。 在java中，线程同步使用最多的方法是使用synchronized关键字，使用synchronized(synchObject)调用相当于获取synchObject的内置锁，对临界区代码段进行排他性保护。synchronized块是java提供的一种原子性内置锁，java中的每个对象都可以把它当做一个同步锁来使用，这些java内置的使用者看不到的锁被称为内部锁，也叫做监视器锁。
线程同步——使用（synchronized）关键字
wu6668的博客
04-14 1763
1.需要线程同步的原因： Java 中允许多线程并行访问，同一时间段内多个线程同时完成各自的操作。但是多个线程同时操作同一个共享数据时，可能会导致数据不准确的问题。 2.线程同步的方法： 可以通过 synchronized 关键字修饰方法实现线程同步，每个Java 对象都有一个内置锁，内置锁会保护使用 synchronized 关键字修饰的方法，要调用该方法就必须先获得锁，否则就处于阻塞状态。 3。synchronized 关键字可以修饰实例方法，也可以修饰静态方法，两者在使用的时候是有区别的。 （1）给实
Java关键字——synchronized
qq_35854212的博客
02-16 699
synchronized使用和原理全解
java同步synchronized关键字用法示例
02-21
Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源时的同步机制。在Java中，当多个线程试图同时访问和修改同一块代码或数据时，可能会导致数据不一致的问题。为了解决这个问题，...
Java关键字大全 Java关键字大全
07-14
17. `synchronized`：`synchronized`关键字用于线程同步，确保同一时间只有一个线程可以执行特定代码段，以防止并发问题。 18. `this`：`this`关键字引用当前对象的引用，通常用于区分实例变量和局部变量，或者在...
Java基础之关键字_Java基础之关键字_源码
10-04
- `synchronized`：同步关键字，用于线程安全。 - `volatile`：确保多线程环境中的变量可见性。 7. 其他关键字： - `break`：跳出当前循环或switch语句。 - `continue`：跳过当前循环剩余部分，继续下一轮循环...
synchronized关键字的实质及用法
03-31
NULL 博文链接：https://seandsky-boyy-163-com.iteye.com/blog/1340783
【Java线程同步机制】
qq_45884946的博客
06-08 306
线程同步机制是一套用于协调线程间的数据访问及活动的机制，该机制用于保障线程安全以及实现这些线程的共同目标。Java平台提供的线程同步机制包括锁、volatile关键字、final关键字、static关键字以及一些相关的API，如Object.wait()/Object.notify()等。
线程同步 各个关键字和方法的使用
热门推荐
小程序
04-15 1万+
1、volatile关键词：用来对共享变量的访问进行同步，上一次写入操作的结果对下一次读取操作是肯定可见的。（在写入volatile变量值之后，CPU缓存中的内容会被写回内存；在读取volatile变量时，CPU缓存中的对应内容会被置为失效，重新从主存中进行读取），volatile不使用锁，性能优于synchronized关键词。 用来确保对一个变量的修改被正确地传播到其他线程中。 例
3.2.2 Java同步关键字和类
拥小抱的小葵花爸爸课堂
05-23 250
查看字节码发现：MONITORENTER,MONITOREXIT; FLAG：ACC_SYNCHRONIZED。 每个对象对应一个Monitor（监视器锁）对象。synchronized基于进出Monitor对象，实现代码块的同步。它的底层依赖操作系统的Mutex Lock（互斥锁）。他是重量级锁性能低。(Monitor(又称管程)，在Java中是ObjectMonitor(JVM源码中C++实现)来实现管程。它是对互斥量和信号量的封装，依赖于底层操作系统的Mutex Lock实现，操作系统实现线程之间的切
Java同步关键字Synchronized深入理解
Ibex-Relieved的专栏
10-28 1515
题记讲讲写这篇博客的原因，因为自认为对synchronized这个关键字很了解了，前几天和一个刚好在找工作的朋友聊到了这个。结果他把面试遇到的一个问题给我出了出来，当我蒙圈的那一刻才懂得自己之前的了解只是皮毛。正文对于synchronized这个关键字，只要是学过java的我们对它都不陌生，而且感觉还非常熟悉。那我们就先来说一说面试和实际使用当中会遇到的两个场景。
Java并发编程学习三：线程同步的关键字以及理解
weixin_33756418的博客
11-19 393
2019独角兽企业重金招聘Python工程师标准>>> ...
同步关键字synchronized的实现（2019-10-08）
dept123的专栏
10-09 389
首先了解常见的锁概念： 互斥锁/独占锁、共享锁 乐观锁、悲观锁 自旋锁、可重入锁、不可重入锁 轻量级锁、重量级锁、偏向锁。 现在回忆一下同步关键字synchronized的使用场景： 1.用于实例方法、静态方法时，隐式指定锁对象；实例方法隐式锁定this对象，静态方法隐式锁定当前类的class对象； 2.用于代码块时，显示指定锁对象。 其特性可以概括为：可重入、独占、悲观。 接下...
Java 多线程 --- 线程同步 内部锁synchronized
HelloWorld
08-07 751
synchronized 关键字 synchronized 关键字修饰静态方法 synchronized代码块 --- synchronized blocks synchronized 保证原子性, 可见性, 有序性
java同步方法关键字
05-05
Java中的同步方法是通过synchronized关键字来实现的。在Java中，每个对象都会有一个锁（也称为监视器）。当一个线程要访问一个对象的同步方法时，它必须先获得这个对象的锁。如果这个锁已经被其他线程持有，那么这个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值