Java线程加锁的三种方式

桃扇骨 2022-04-11 20:15 347阅读 0赞

# 1.对象锁（同步块）——锁某一个对象 #

> **对象锁**：顾名思义给对象上锁
> 
> 当A线程访问一个object的时候，首先会获取该对象的对象锁，然后访问锁定的代码，而B线程访问一个对象object多顶的代码区时，因为线程A之前获取到对象object的对象锁，因此线程B访问同步代码区的时候会被阻塞，直到线程A执行完同步代码块，然后释放对象锁，B线程获取对象object的对象锁，才能进行访问同步代码块
> 
> 用法：synchronized (this)\{   
> //—-同步代码块———   
> \}   
> this表示当前访问同步代码区的对象   
> 特别注意：只要同步代码区的是同一个对象时才能实现互斥访问的效果

示例：

package com.demo;
    
    public class SyncBlock {
    	public static int count;
    	public static Object lock = new Object();
    	
    	public static void main(String[] args) throws InterruptedException {
    		Thread t1=new Thread(new MyRunnable(),"线程1");
    		Thread t2=new Thread(new MyRunnable(),"线程2");
    		t1.start();
    		t2.start();
    		t1.join();
    		t2.join();
    		System.out.println("count="+count);
    	}
    	
    	static class MyRunnable implements Runnable{
    		
    		@Override
    		public void run() {
    			for (int i = 0; i < 10000; i++) {
    				synchronized (lock) {
    					count++;
    				}
    			}
    		}
    		
    	}
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTk0MTI5OA_size_16_color_FFFFFF_t_70][]

# 2.类锁——锁当前类（方法上有static关键字修饰） #

> **类锁**：顾名思义给类上锁–>具体就是给类的字节码上锁
> 
> 当线程A访问类锁锁定的同步代码块时，线程B访问同步代码块，因为A之前已经获取类锁，因此线程B只能A执行完同步代码块后才能获取类锁进行访问

示例：

package com.demo;
    
    public class SyncClass {
    	
    	private static int count;
    	public static void main(String[] args) throws InterruptedException {
    		Thread t1 = new Thread(new MyRunnable());
    		Thread t2 = new Thread(new MyRunnable());
    		t1.start();
    		t2.start();
    		t1.join();
    		t2.join();
    		System.out.println(count);
    		
    	}
    	
    	static class MyRunnable implements Runnable{
    
    		
    		public static synchronized void increase() {
    			count++;
    		}
    		
    		@Override
    		public void run() {
    			for(int i=0;i<10000;i++) {
    				increase();
    			}
    		}
    		
    	}
    	
    	
    }

结果：同上

# 3.实例锁——锁的是当前实例（方法上没有static修饰，表示只能锁当前实例） #

> 同一个实力访问的线程才是安全的，不同的线程访问则不安全

示例：

package com.demo;
    /**
     * @author dxchen
     *
     */
    public class SyncInstance {
    	public static int count;
    	
    	public static void main(String[] args) throws InterruptedException {
    		MyRunnable target = new MyRunnable();
    		Thread t1 = new Thread(target,"线程1");
    		Thread t2 = new Thread(target,"线程2");
    		t1.start();
    		t2.start();
    		t1.join();
    		t2.join();
    		System.out.println(count);
    		
    	}
    	
    	static class MyRunnable implements Runnable{
    		/**
    		 * 对count操作的实例方法
    		 */
    		public synchronized void increase() {
    			count++;
    		}
    		
    		@Override
    		public void run() {
    			for (int i = 0; i < 10000000; i++) {
    				increase();
    			}
    			
    		}
    	}
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTk0MTI5OA_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTk0MTI5OA_size_16_color_FFFFFF_t_70 2][]

参考：[https://blog.csdn.net/yang1464657625/article/details/56278102][https_blog.csdn.net_yang1464657625_article_details_56278102]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTk0MTI5OA_size_16_color_FFFFFF_t_70]: /images/20220412/ba263686fe3c4b99bde987d4412e9b9a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTk0MTI5OA_size_16_color_FFFFFF_t_70 1]: /images/20220412/b385c0c0813d42dc93a59be7a4ba32ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTk0MTI5OA_size_16_color_FFFFFF_t_70 2]: /images/20220412/aea6c27dc5784adf8eee5da726b88f29.png
[https_blog.csdn.net_yang1464657625_article_details_56278102]: https://blog.csdn.net/yang1464657625/article/details/56278102