Java Synchronized & Lock

最新推荐文章于 2023-06-28 21:28:09 发布
最新推荐文章于 2023-06-28 21:28:09 发布
阅读量137 收藏
点赞数
分类专栏： Multithreading 文章标签： java thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Stephen_mu/article/details/120857430
版权

目的

解决在多线程访问同一资源时，线程之间的同步互斥问题

Synchronized

对象锁

在Java中，每一个对象都拥有一个锁标记（monitor），也称为监视器，多线程同时访问某个对象时，线程只有获取了该对象的锁才能访问
在Java中，可以使用synchronized关键字来标记一个方法或者代码块，当某个线程调用该对象的synchronized方法或者访问synchronized代码块时，这个线程便获得了该对象的锁，其他线程暂时无法访问这个方法，只有等待这个方法执行完毕或者代码块执行完毕，这个线程才会释放该对象的锁，其他线程才能执行这个方法或者代码块

Example：

public class MySynchronized {

    public static void main(String[] args) {
        
        final Business business = new Business();
        new Thread(new Runnable() {
            @Override
            public void run() {
                business.outSub();
            }
        }).start();
        
        business.outMain();
    }
}

class Business {
    
    public void outSub() {
        for(int i=0;i<10;i++) {
            System.out.println("Sub Thread loop sequence: " + i);
        }
    }
    
    public void outMain() {
        for(int i=0;i<10;i++) {
            System.out.println("Main Thread loop sequence: " + i);
        }
    }
}
//由于未使用同步机制，Main线程和Sub Thread会交替打印内容
Result：
Main Thread loop sequence: 0
Sub Thread loop sequence: 0
Main Thread loop sequence: 1
Sub Thread loop sequence: 1
Main Thread loop sequence: 2
Sub Thread loop sequence: 2
Main Thread loop sequence: 3
Sub Thread loop sequence: 3
Main Thread loop sequence: 4
Sub Thread loop sequence: 4
Sub Thread loop sequence: 5
Main Thread loop sequence: 5
Sub Thread loop sequence: 6
Sub Thread loop sequence: 7
Main Thread loop sequence: 6
Sub Thread loop sequence: 8
Sub Thread loop sequence: 9
Main Thread loop sequence: 7
Main Thread loop sequence: 8
Main Thread loop sequence: 9

Example2:

public class MySynchronized {

    public static void main(String[] args) {
        
        final Business business = new Business();
        new Thread(new Runnable() {
            @Override
            public void run() {
                business.outSub();
            }
        }).start();
        
        business.outMain();
    }
}

class Business {
     //我们在线程需要执行的方法上加上Synchronized关键字，使线程对该方法的调用达到同步与互斥
    public synchronized void outSub() {
        for(int i=0;i<10;i++) {
            System.out.println("Sub Thread loop sequence: " + i);
        }
    }
    //我们在线程需要执行的方法上加上Synchronized关键字，使线程对该方法的调用达到同步与互斥
    public synchronized void outMain() {
        for(int i=0;i<10;i++) {
            System.out.println("Main Thread loop sequence: " + i);
        }
    }
}
//由于使用Synchronized实现线程之间的同步与互斥，线程执行个字的方法时由于获取到了对象的锁，而两个线程使用的同一个类对象，则一旦某一个线程先拿到对象的锁，另一个线程就必须等待该线程执行结束，释放对象的锁后，才能重新获得对象的锁执行自己的代码
Result:
Main Thread loop sequence: 0
Main Thread loop sequence: 1
Main Thread loop sequence: 2
Main Thread loop sequence: 3
Main Thread loop sequence: 4
Main Thread loop sequence: 5
Main Thread loop sequence: 6
Main Thread loop sequence: 7
Main Thread loop sequence: 8
Main Thread loop sequence: 9
Sub Thread loop sequence: 0
Sub Thread loop sequence: 1
Sub Thread loop sequence: 2
Sub Thread loop sequence: 3
Sub Thread loop sequence: 4
Sub Thread loop sequence: 5
Sub Thread loop sequence: 6
Sub Thread loop sequence: 7
Sub Thread loop sequence: 8
Sub Thread loop sequence: 9

Tips：

  1. 如果某一个线程正在执行对象的Synchronized方法，那么该对象的所有Synchronized方法都不能被其他线程所访问，因为每一个对象只有一把锁，当一个线程运行synchronized方法时，就获得了该对象的锁，其他线程自然也就无法获取到对象的锁（除非得到该线程运行结束或出现异常释放锁，当出现异常时，JVM会自动释放当前线程占用的锁，因此不会由于异常导致出现死锁现象
  2. 由于synchronized维护的是对象的锁，因此不同对象的synchronized方法可以被多个线程同时访问
  3. 当一个线程访问对象的synchronized方法，此时允许其他线程访问那些非Synchronized方法，因为运行那些非Synchronized方法并不需要获取对象的锁

类锁

每个类也会有一个锁，它可以用来控制对static数据成员的并发访问。
并且如果一个线程执行一个对象的非static synchronized方法，另外一个线程需要执行这个对象所属类的static synchronized方法，此时不会发生互斥现象，因为访问static synchronized方法占用的是类锁，而访问非static synchronized方法占用的是对象锁，所以不存在互斥现象

public class MySynchronized {

    public static void main(String[] args) {
        
        final Business business = new Business();
        new Thread(new Runnable() {
            @Override
            public void run() {
                business.outStaticSub();
            }
        }).start();
        
        business.outMain();
    }
}

class Business {
    
    public static synchronized void outStaticSub() {
        for(int i=0;i<10;i++) {
            System.out.println("static Sub Thread loop sequence: " + i);
        }
    }
    
    public synchronized void outMain() {
        for(int i=0;i<10;i++) {
            System.out.println("Main Thread loop sequence: " + i);
        }
    }
}

//由于此时static synchronized方法占用了类锁，和普通的Synchronized方法占用的对象的锁并不冲突，所以结果为可能存在交替输出
Result:
Main Thread loop sequence: 0
Main Thread loop sequence: 1
Main Thread loop sequence: 2
Main Thread loop sequence: 3
Main Thread loop sequence: 4
static Sub Thread loop sequence: 0
Main Thread loop sequence: 5
Main Thread loop sequence: 6
static Sub Thread loop sequence: 1
Main Thread loop sequence: 7
static Sub Thread loop sequence: 2
Main Thread loop sequence: 8
static Sub Thread loop sequence: 3
Main Thread loop sequence: 9
static Sub Thread loop sequence: 4
static Sub Thread loop sequence: 5
static Sub Thread loop sequence: 6
static Sub Thread loop sequence: 7
static Sub Thread loop sequence: 8
static Sub Thread loop sequence: 9

Lock

After Java5
既然自Java5推出并发concurrent包，自然是Synchronized存在诸多的缺陷，我们先来讨论下这些缺陷，就更加能体会到Lock的好了

1.假如某一线程在执行synchronized过程中调用sleep()或者陷入死循环导致该线程一直占用锁，而其他线程也一直获取不到锁，此时程序效率将大大降低，因此我们需要实现超时即释放锁，而synchronized作为Java内置特性此时就无能为力了
2.假如我们的程序操作某一份文件，读写方法我们都加上了synchronized关键字，导致线程间写方法互斥，写与读互斥，读与读互斥。而实际情况中线程间读方法与读方法不应该互斥，多个线程之间允许同时读取共享资源的内容

Lock

public interface Lock {
    void lock();    //获取锁
    void lockInterruptibly() throws InterruptedException;  // 使用及原理参考下方的Example
    boolean tryLock();	//获取锁，如果得到锁返回true，反之返回false
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException; 	//获取锁的过程中允许等待一段时间，如果得到锁返回true，反之返回false
	void unlock();	//释放锁
	Condition newCondition();
}

lockInterruptibly：当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。
　　由于lockInterruptibly()的声明中抛出了异常，所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出InterruptedException
注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。因为本身在前面的文章中讲过单独调用interrupt()方法不能中断正在运行过程中的线程，只能中断阻塞过程中的线程。因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去

ReentrantLock

AbstractOwnableSynchronizer源码

public abstract class AbstractOwnableSynchronizer	implements java.io.Serializable {
    protected AbstractOwnableSynchronizer() { }
    private transient Thread exclusiveOwnerThread;
    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }
    protected final Thread getExclusiveOwnerThread() {
        return exclusiveOwnerThread;
    }
}

AbstractOwnableSynchronizer源码

public abstract class AbstractQueuedSynchronizer	extends AbstractOwnableSynchronizer	implements java.io.Serializable {
	private transient volatile Node head;
   	private transient volatile Node tail;
    private volatile int state;
    	
	static final class Node {
        static final Node SHARED = new Node();
        static final Node EXCLUSIVE = null;
        static final int CANCELLED =  1;
        static final int SIGNAL    = -1;
        static final int CONDITION = -2;
        static final int PROPAGATE = -3;
		volatile int waitStatus;
		volatile Node prev;
		volatile Node next;
		volatile Thread thread;
		Node nextWaiter;
     }
     
    private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }
    ......
	
}

ReentrantLock源码

public class ReentrantLock implements Lock, java.io.Serializable {
	private final Sync sync;
	public ReentrantLock() {
        sync = new NonfairSync(); //默认为非公平锁
    }
    
    public ReentrantLock(boolean fair) { //也可以传入参数创建公平锁
        sync = fair ? new FairSync() : new NonfairSync();
    }
    
    public void lock() {
        sync.lock();
    }
    
	abstract static class Sync extends AbstractQueuedSynchronizer {
		abstract void lock();
		......
	}
	
	static final class NonfairSync extends Sync {
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
    }

	static final class FairSync extends Sync {
        final void lock() {
            acquire(1);
        }
    }
}

Example:

public class MyReentrantLock {
    
    public static void main(String[] args) {
        Business business =new Business();
        new Thread(new Runnable() {
            @Override
            public void run() {
                business.output2();
            }
        }).start();
        
        business.output2();
    }
}

class Business {
    Lock lock = new ReentrantLock();
    
    public void output() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " obtain the lock...");
            Thread.sleep(3000);
        }catch (Exception e) {
            // TODO: handle exception
        }finally {
            System.out.println(Thread.currentThread().getName() + " release the lock...");
            lock.unlock();
        }
    }
    
    public void output2() {
        if(lock.tryLock()) {
            try {
                System.out.println(Thread.currentThread().getName() + " obtain the lock...");
                Thread.sleep(3000);
            }catch (Exception e) {
                // TODO: handle exception
            }finally {
                System.out.println(Thread.currentThread().getName() + " release the lock...");
                lock.unlock();
            }
        }
    }
}

Example：lock.lockInterruptibly()

public class InterruptTest {
    
    public static void main(String[] args) throws InterruptedException{
        //only defined one ReentrantLock
        MyBusiness2 myBusiness2 = new MyBusiness2();
        
        Thread subThread = new Thread(new Runnable() {
            @Override
            public void run() {
                    myBusiness2.output();
            }
        });
        
        Thread subThread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                    myBusiness2.output();
            }
        });
        
        subThread.start();
        // let subThread obtain the lock, we test for subThread2 waiting for the lock
        Thread.sleep(100);
        subThread2.start();
            
        subThread2.interrupt();
    }  
}
 
class MyBusiness2 {
    
    // object lock
    private Lock lock = new ReentrantLock();   
    
    public void output(){
        String currThreadName = Thread.currentThread().getName();
        try {
            System.out.println(currThreadName+" preparing to obtain the lock");
            lock.lockInterruptibly();
            System.out.println(currThreadName+" obtain the lock, then sleep... ");
            for (int i=0; i<5; i++) {
                Thread.sleep(1000);
                System.out.println(currThreadName + " : " + i);
            }
        }catch (InterruptedException e) {
            System.out.println(currThreadName+" interrupted" );
        }finally {
            try {
                lock.unlock();
                System.out.println(currThreadName+" running over... then release the lock..." );
                
            }catch (Exception e) {
                System.out.println(currThreadName+" before obtain the lock alr interrupted..." );
            }
        }  
    }
}

Result:
Thread-0 preparing to obtain the lock
Thread-0 obtain the lock, then sleep... 
Thread-1 preparing to obtain the lock
Thread-1 interrupted
Thread-1 before obtain the lock alr interrupted...
Thread-0 : 0
Thread-0 : 1
Thread-0 : 2
Thread-0 : 3
Thread-0 : 4
Thread-0 running over... then release the lock...

lockInterruptibly作用：方法能够中断等待获取锁的线程，例如上方的例子，subThread先一步subThread2获取到锁，此时subThread2等待subThread执行结束释放锁，但是在subThread运行过程中，subThread2调用了线程的中断方法，那么此时subThread2将退出锁等待，并会抛出InterruptedException，并且假如后续存在中断锁操作的话，subThread2也会抛出异常吗，因为他自始至终根本没有获取到锁。

ReadWriteLock

ReadWriteLock 顾名思义，将读写操作分开加锁的操作（多个读锁不互斥，读锁与写锁互斥，写锁与写锁互斥）

public interface ReadWriteLock {
    Lock readLock();
    Lock writeLock();
}

ReentrantReadWriteLock

public class ReentrantReadWriteLock	implements ReadWriteLock, java.io.Serializable {
    /** Inner class providing readlock */
    private final ReentrantReadWriteLock.ReadLock readerLock;
    /** Inner class providing writelock */
    private final ReentrantReadWriteLock.WriteLock writerLock;
    /** Performs all synchronization mechanics */
    final Sync sync;
    
    private static final sun.misc.Unsafe UNSAFE;
    private static final long TID_OFFSET;
    static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class<?> tk = Thread.class;
            TID_OFFSET = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("tid"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }
	
	public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }
	
	abstract static class Sync extends AbstractQueuedSynchronizer {
		private transient ThreadLocalHoldCounter readHolds;
		private transient HoldCounter cachedHoldCounter;
		private transient Thread firstReader = null;
        private transient int firstReaderHoldCount;

        Sync() {
            readHolds = new ThreadLocalHoldCounter();
            setState(getState()); // ensures visibility of readHolds
        }
        
		static final class HoldCounter {
            int count = 0;
            // Use id, not reference, to avoid garbage retention
            final long tid = getThreadId(Thread.currentThread());
        }
		
		static final class ThreadLocalHoldCounter
            extends ThreadLocal<HoldCounter> {
            public HoldCounter initialValue() {
                return new HoldCounter();
            }
        }
	}

	/**
     * Nonfair version of Sync
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -8159625535654395037L;
        final boolean writerShouldBlock() {
            return false; // writers can always barge
        }
        final boolean readerShouldBlock() {
            /* As a heuristic to avoid indefinite writer starvation,
             * block if the thread that momentarily appears to be head
             * of queue, if one exists, is a waiting writer.  This is
             * only a probabilistic effect since a new reader will not
             * block if there is a waiting writer behind other enabled
             * readers that have not yet drained from the queue.
             */
            return apparentlyFirstQueuedIsExclusive();
        }
    }

    /**
     * Fair version of Sync
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -2274990926593161451L;
        final boolean writerShouldBlock() {
            return hasQueuedPredecessors();
        }
        final boolean readerShouldBlock() {
            return hasQueuedPredecessors();
        }
    }
	
	public static class ReadLock implements Lock, java.io.Serializable {
        private final Sync sync;
		protected ReadLock(ReentrantReadWriteLock lock) {
            sync = lock.sync;
        }
        public void lock() {
            sync.acquireShared(1);
        }
        ......
	}

	public static class WriteLock implements Lock, java.io.Serializable {
        private final Sync sync;
        protected WriteLock(ReentrantReadWriteLock lock) {
            sync = lock.sync;
        }
        ......
	}

}

Example：

public class MyReadWriteLock {
    public static void main(String[] args) {
        MyBusiness myBusiness =new MyBusiness();
        ExecutorService  threadPool = Executors.newCachedThreadPool();
        
        for(int i=0;i<5;i++) {
          Thread t1 =  new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        myBusiness.readData();
                    } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            });
            
          Thread t2 =  new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        myBusiness.writeData();
                    } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            });
          
          threadPool.execute(t1);
          threadPool.execute(t2);
        }
        
        threadPool.shutdown();
    }
}


class MyBusiness{
    ReadWriteLock readWriteLock =new ReentrantReadWriteLock();
    
    private int sharedData; 
    public void readData() {
        String currThreadName = Thread.currentThread().getName();
        readWriteLock.readLock().lock();
        try {
            System.out.println(currThreadName + " ready --- read data: ");
        } catch (Exception e) {
            
        }finally {
            System.out.println(currThreadName + " read data: " + sharedData);
            readWriteLock.readLock().unlock();
        }
    }
    
    public void writeData() {
        String currThreadName = Thread.currentThread().getName();
        readWriteLock.writeLock().lock();
        try {
            System.out.println(currThreadName + " ready --- write data: ");
            sharedData = new Random().nextInt(10000);
        } catch (Exception e) {
            
        }finally {
            System.out.println(currThreadName + " write data: " + sharedData);
            readWriteLock.writeLock().unlock();
        }
    }
}

Result:
Thread-0 ready --- read data: 
Thread-0 read data: 0
Thread-1 ready --- write data: 
Thread-1 write data: 147
Thread-7 ready --- write data: 
Thread-7 write data: 753
Thread-2 ready --- read data: 
Thread-2 read data: 753
Thread-3 ready --- write data: 
Thread-3 write data: 4545
Thread-4 ready --- read data: 
Thread-4 read data: 4545
Thread-5 ready --- write data: 
Thread-5 write data: 2928
Thread-6 ready --- read data: 
Thread-6 read data: 2928
Thread-9 ready --- write data: 
Thread-9 write data: 9244
Thread-8 ready --- read data: 
Thread-8 read data: 9244

ReadWriteLock总结：如果不使用锁，多个线程访问共享数据，必然出现多线程安全问题，但是如果我们使用普通的ReentrantLock存在多线程所有操作(读-读，读-写，写-写)都互斥，导致程序执行效率不高，显示情况中多线程（读-读）操作不应该互斥，因此ReadWriteLock将共享数据的读写操作分离，实现多线程（读-读）操作不互斥，（读-写，写-写）操作依旧互斥，保证线程共享数据安全的同时还提高了程序效率。

塞北沐秋
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized底层源码
huapro.vip的程序人生
03-11 991
一、synchronized的使用场景 synchronized一般使用在下面这几种场景： 修饰代码块，指定一个加锁的对象，给对象加锁 public Demo1{ Object lock=new Object(); public void test1(){ synchronized(lock){ } } } 修饰静态方法，对当前类的Class对象加锁 public class Demo2 { //形式一 public void test1
synchronized源码解析
ckiuick的博客
01-19 706
偏向锁、无锁、轻量锁、重量锁源码级解析
10-锁（synchronized和Lock）
titanium的博客
02-22 3012
锁（synchronized和lock）
从源码全面解析 synchronized 关键字的来龙去脉
BASK2311的博客
03-30 324
说实话，看了这几个源码，感觉作用不太大.....面试能吹到源码这一步，也是你牛逼了个人感觉，记住上面的流程，再记住park和unpark就够了LockSupport 的 park 和 unpark 是依赖 JVM（此处语境讨论 Hotspot）调用操作系统的 pthread_mutex_lock 和 pthread_cond_wait ， 前者是保护后者和 counter 变量的互斥锁，保证只有一个线程操作 counter 变量和 condtion 上的等待队列又是一篇大工程的文章结束了。
JAVA篇_线程锁synchronized、lock与死锁
qq_45878219的博客
08-09 3999
在分布式开发中，锁是线程控制的重要途径。Java为此也提供了2种锁机制，synchronized和lock。 区别： 1、lock是一个接口，而synchronized是java的一个关键字。 2、synchronized在发生异常时会自动释放占有的锁，因此不会出现死锁；而lock发生异常时，不会主动释放占有的锁，必须手动来释放锁，可能引起死锁的发生，Java中每一个对象都可以作为锁，这是synchronized实现同步的基础： 3、Lock是显示锁（需要手动开关），synchronized始于隐式
并发编程之synchronized&amp;Lock&amp;AQS详解(1)1
08-03
一、同步省略 二、将堆分配转化为栈分配 三、分离对象或标量替换
Java synchronized关键字和Lock接口实现原理
08-25
主要介绍了Java synchronized关键字和Lock接口实现原理,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java编程synchronized与lock的区别【推荐】
08-29
互联网信息泛滥环境下少有的良心之作！如果您想对Java编程synchronized与lock的区别有所了解，这篇文章绝对值得！分享给大家，供需要的朋友参考。不说了，我先学习去了。
Synchronized 和 Lock 的区别和使用场景
01-20
并发编程中，锁是经常需要用到的，今天我们一起来看下Java中的锁机制：synchronized和lock。 Synchronized 和 Lock的概念 Synchronized 是Java 并发编程中很重要的关键字，另外一个很重要的是 volatile。Syncronized...
关于synchronized、Lock的深入理解
12-21
众所周知，synchronized锁是JAVA的关键字，按理说是JAVA语言内置的特性，那为什么还要使用Lock呢 我们先说一说synchronized，当一个方法或者代码块被synchronized修饰，并执行到此方法或者代码块时，获取到锁并执行...
synchronized并发讲解源码.zip
03-16
我自己的博客所附带的案例源码，我的博客标题名称是&quot;synchronized并发讲解&quot;,关注我等待跟多更新
深入浅出synchronized的原理与源码
最新发布
m0_37618089的博客
06-28 370
synchronized
Synchronized 与Lock（ReentrantLock）区别
nswdiphone6的博客
03-19 250
Synchronized 与Lock（ReentrantLock）区别： 原始构成 sync 是关键字属于JVM层面，monitorenter(底层是通过monitor对象来完成，其实wait/notify等方法也依赖于monitor对象，只有在同步代码块或方法中才能调用wait/notify等方法) Lock 是具体类（JUC包下的）是API层面的锁。 使用方法： synchronized 不需要用户去手动释放锁，当synchronized代码执行完成后系统会自动让线程释放对锁的占用
重回synchronized（源码解读与实战解析篇）
Liyizhi111的博客
11-23 892
以下获取和释放流程皆出自源码
synchronized 源码级详细解析
weixin_44062380的博客
04-06 386
多线程基础 这里主要讲synchronized关键字，JUC有另外的讲解 1、Synchronized简介 Synchronized作用 保证在同一时刻，最多只有一个线程执行该段代码，以达到保证并发安全的效果。 Synchronized的地位 是java关键字 是最基本的互斥手段 是并发编程的元老级角色，是并发编程的必学内容 不使用并发有什么后果 public class MissedRequest { private static int num=0; public static v
Java 中的线程安全性问题——synchronized / Lock
weixin_46448719的博客
03-29 1649
多线程的“共享性”，意味着在程序中的变量可以由多个线程同时访问。而“可变性”则意味着变量的值在其生命周期内可以发生变化。本篇博客记录在 Java 的多线程学习中如何防止多个线程在数据上发生不受控的并发访问~ 多线程的“共享性”，意味着在程序中的变量可以由多个线程同时访问。而“可变性”则意味着变量的值在其生命周期内可以发生变化。本篇博客记录在 Java 的多线程学习中如何防止多个线程在数据上发生不受控的并发访问~ 一个对象是否需要是线程安全的，取决于它是否被多个线程访问。这指的是在程序中访问对象的方
java 锁机制_java 锁机制(synchronized 与 Lock)
weixin_42394785的博客
02-12 215
在java中，解决同步问题，很多时候都会使用到synchronized和Lock，这两者都是在多线程并发时候常使用的锁机制。synchronized是java中的一个关键字，也就是说是java内置的一个特性。当一个线程访问一个被synchronized修饰的代码块，会自动获取对应的一个锁，并在执行该代码块时，其他线程想访问这个代码块，会一直处于等待状态，自有等该线程释放锁后，其他线程进行资源竞争，...
JAVA锁：synchronized和Lock
G_yongchang的博客
12-27 352
锁的类型可分为四种： 1、可重入锁（synchronized和ReentrantLock）：在执行对象中，所有方法不再获取锁。 2、可中断锁（synchronized是不可中断锁，Lock是可中断锁）：在等待获取中可中断 3、公平锁：（ReentranLock和ReentranReadWriteLock）：按等待获取线程的等待实际进行排队，等待时间长的优先获取锁。 4、读写锁：（ReadWriteLock和ReentrantReadWriteLock）：对资源的处理可分成2个部分处理，读的时候可以多线程一起
java synchronized和lock区别
03-16
Java中的synchronized和lock都是用于实现线程同步的机制，但是它们之间有一些区别： 1. synchronized是Java语言内置的关键字，而lock是一个Java类，需要手动创建和释放。 2. synchronized只能用于同步方法或同步...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值