Java基础之线程锁相关知识总结

2024-04-02 19:04:59 493人浏览薄情痞子

Python 官方文档：入门教程 => 点击学习

摘要

一、 synchronized关键字 1.对象锁 a.当使用对象锁的时候，注意要是相同的对象，并且当有线程正在访问对象锁内部的代码的时候，其他线程无法访问。(注意无法访问的范围)。

一、 synchronized关键字

1.对象锁
a.当使用对象锁的时候，注意要是相同的对象，并且当有线程正在访问对象锁内部的代码的时候，其他线程无法访问。(注意无法访问的范围)。
b.但是并不影响没有使用对象锁的部分的代码的运行。

对象锁分为两类一个叫做synchronized代码块(圆括号内是普通类的对象)，另外一个是sybchronized修饰普通成员方法。它们二者其实可以通过this关键字进项转化。

2.类锁
a. 当使用类锁的时候，只要是同一个类的对象.当有线程正在访问类锁内部的代码的时候，其他线程无法访问。(注意无法访问的范围)
b. 但是并不影响没有使用类锁的部分的代码的运

对象锁分为两类一个叫做synchronized代码块(圆括号内是class对象)，另外一个是sybchronized修饰静态成员方法。它们二者其实可以通过class对象进项转化。

注意: 类锁和对象锁之间没有关系.

1、不使用线程锁

如果没有加synchronized关键字，会产生线程交错运行



public class A {

	void test() {
		for(int i=0;i<10;i++) {
			System.out.println("线程："+i);
		}
	}
}


public class MyThread1 extends Thread{

	A a;
	
	public void run() {
		a.test();
	}
}


public class MyThread2 extends Thread{

	A a;
	
	public void run() {
		a.test();
	}
}


		A a = new A();
		
		MyThread1 t1 = new MyThread1();
		MyThread2 t2 = new MyThread2();
		
		t1.a = a;
		t2.a = a;
		
		t1.start();
		t2.start();
	}

}

产生如下运行结果：
线程：0
线程：1
线程：2
线程：3
线程：4
线程：0
线程：5
线程：6
线程：7
线程：8
线程：9
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9

2、使用对象锁

将A类中test方法代码改成如下代码，其他不变，运行测试类可以产生如下结果



public class A {

	void test() {
		System.out.println("线程开始");
		synchronized(this) {
			for(int i=0;i<10;i++) {
				System.out.println("线程："+i);
			}
		}
		System.out.println("线程结束");
	}
}
运行测试类会产生如下结果：（注意：”线程开始“不是在对象锁中的内容）

线程开始
线程：0
线程：1
线程开始
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9
线程：0
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程结束
线程：7
线程：8
线程：9
线程结束

使用synchronized直接修饰方法等价于synchronized(this)修饰方法内的全部代码



public class A {

	synchronized void test() {
		System.out.println("线程开始");
			
		for(int i=0;i<10;i++) {	
			System.out.println("线程："+i);	
		}
			
		System.out.println("线程结束");
	}
	
	void test1() {
		synchronized (this) {
			System.out.println("线程开始");
			
			for(int i=0;i<10;i++) {	
				System.out.println("线程："+i);	
			}
				
			System.out.println("线程结束");
		}
	}
}
其他代码是一样的，在MyThread1和MyThread2中无论调用test还是test1，结果是一样的，如下：

线程开始
线程：0
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9
线程结束
线程开始
线程：0
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9
线程结束

对象锁对不同的方法也是有用的（类锁也是如此）



public class A {

//	synchronized void test() {	
//		for(int i=0;i<10;i++) {	
//			System.out.println("方法test："+i);	
//		}
//	}
	void test() {	
		synchronized(this) {
			for(int i=0;i<10;i++) {	
				System.out.println("方法test："+i);	
			}
		}
	}
	
//	synchronized void test1() {	
//		for(int i=0;i<10;i++) {	
//			System.out.println("方法test1："+i);	
//		}
//	}
	void test1() {
		synchronized(this) {
			for(int i=0;i<10;i++) {	
				System.out.println("方法test1："+i);	
			}
		}
	}
}
MyThread1中调用test方法，MyThread2中调用test1方法，运行结果如下：

方法test：0
方法test：1
方法test：2
方法test：3
方法test：4
方法test：5
方法test：6
方法test：7
方法test：8
方法test：9
方法test1：0
方法test1：1
方法test1：2
方法test1：3
方法test1：4
方法test1：5
方法test1：6
方法test1：7
方法test1：8
方法test1：9

3、使用类锁

演示当A类中的test方法使用对象锁时，不同对象调用test方法时对象锁是起不到任何作用的



public class A {

	void test() {
		synchronized(this) {
			for(int i=0;i<10;i++) {
				System.out.println("线程："+i);
			}
		}
	}
}

MyThread1和MyThread2是一样的，主要在测试程序的不同

测试程序：
public class Entrance {

	public static void main(String[] args) {
		
		
		A a1 = new A();
		A a2 = new A();
		
		MyThread1 t1 = new MyThread1();
		MyThread2 t2 = new MyThread2();
		
		t1.a = a1;
		t2.a = a2;
		
		t1.start();
		t2.start();
	}

}

运行结果：

线程：0
线程：1
线程：2
线程：3
线程：4
线程：0
线程：5
线程：6
线程：7
线程：8
线程：9
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9

使用类锁会改变这种情况，无论是那个对象，只要调用的是同一个方法就会产生锁



public class A {

	void test() {
		synchronized(A.class) {
			for(int i=0;i<10;i++) {
				System.out.println("线程："+i);
			}
		}
	}
}

运行结果：
线程：0
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9
线程：0
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9



public class A {

	void test() {
		synchronized(A.class) {
			for(int i=0;i<10;i++) {
				System.out.println("线程："+i);
			}
		}
	}
}

运行结果：
线程：0
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9
线程：0
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9

类锁这对象锁之间是没有任何关系，互不影响互不干涉



public class A {
	
	synchronized void test() {
			for(int i=0;i<10;i++) {
				System.out.println("方法test："+i);
			}
	}	
	synchronized static void test1() {
		for(int i=0;i<10;i++) {
			System.out.println("方法test1："+i);
		}
	}
}

MyThread1调用test方法，使用对象锁，MyThread2调用test1方法，使用类锁

测试程序
public class Entrance {

	public static void main(String[] args) {

		A a1 = new A();
		A a2 = new A();
		
		MyThread1 t1 = new MyThread1();
		MyThread2 t2 = new MyThread2();
		
		
//		t1.a = a1;
//		t2.a = a1;
		
		t1.a = a1;
		t2.a = a2;
		
		t1.start();
		t2.start();
	}

}

运行结果：

方法test：0
方法test：1
方法test1：0
方法test1：1
方法test1：2
方法test1：3
方法test1：4
方法test1：5
方法test1：6
方法test1：7
方法test1：8
方法test1：9
方法test：2
方法test：3
方法test：4
方法test：5
方法test：6
方法test：7
方法test：8
方法test：9

到此这篇关于Java基础之线程锁相关知识总结的文章就介绍到这了,更多相关Java线程锁内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

--结束END--

本文标题: Java基础之线程锁相关知识总结

本文链接: https://lsjlt.com/news/129429.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341