一,内部锁:synchronized关键字
java中的每个对象都有一个与之关联的内部锁(intrinsic loock)这种锁也称为监视器(Monitor),这种内部锁是一种排他锁,可以保障原子性,可见性与有序性
内部锁是通过synchronized关键字实现的synchronize关键字修饰代码块,修饰改方法
修饰代码块的语法:
synchronize(对象锁){
同步代码块
}
修饰实例方法就称为同步实例方法
修饰静态方式就称为同步静态方法
1.1 synchronized 同步代码块
开启两个线程,让两个线程调用同一个方法
public class Text01 {
public static void main(String[] args) {
//创建两个线程分别调用mm方法
//先创建Test实例对象通过对象名调用对象
Text01 test = new Text01();
//启动第一个线程
new Thread(new Runnable() {
@Override
public void run() {
test.mm();
}
}).start();
//启动第二个线程
new Thread(new Runnable() {
@Override
public void run() {
test.mm();
}
}).start();
}
//定义一个方法打印一百行字符串
public void mm(){
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}
这样我们得到的结果会使两条线程相互穿插的都打印了一百行数据,一共两百行
如果我们希望同步代码块,即一个线程先打印完一百行数据,另一个线程再打印数据,一共两百行
public class Text01 {
public static void main(String[] args) {
//创建两个线程分别调用mm方法
//先创建Test实例对象通过对象名调用对象
Text01 test = new Text01();
//启动第一个线程
new Thread(new Runnable() {
@Override
public void run() {
test.mm();
}
}).start();
//启动第二个线程
new Thread(new Runnable() {
@Override
public void run() {
test.mm();
}
}).start();
}
//定义一个方法打印一百行字符串
public void mm(){
//我们通常使用this 即当前对象作为锁对象
synchronized (this){
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}
}
我们需要理解this到底值得是谁
如果代码改为如下情况,打印结果会发生变化吗?
public class Text01 {
public static void main(String[] args) {
//创建两个线程分别调用mm方法
//先创建Test实例对象通过对象名调用对象
Text01 test01 = new Text01();
Text01 test02 = new Text01();
//启动第一个线程
new Thread(new Runnable() {
@Override
public void run() {
test01.mm();
}
}).start();
//启动第二个线程
new Thread(new Runnable() {
@Override
public void run() {
test02.mm();
}
}).start();
}
//定义一个方法打印一百行字符串
public void mm(){
//我们通常使用this 即当前对象作为锁对象
synchronized (this){
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}
}
会发生变化
synchronize中的this指的是调用这个方法的对象。第一个线程与第二个线程调用mm方法的对象都不一样,无法实现同步代码块。
我们也可以使用一个常量作为锁对象
public class Text02 {
public static void main(String[] args) {
//创建两个线程分别调用mm方法
//先创建Test实例对象通过对象名调用对象
Text02 test01 = new Text02();
Text02 test02 = new Text02();
//启动第一个线程
new Thread(new Runnable() {
@Override
public void run() {
test01.mm();
}
}).start();
//启动第二个线程
new Thread(new Runnable() {
@Override
public void run() {
test02.mm();
}
}).start();
}
public static final Object obj =new Object();
//定义一个方法打印一百行字符串
public void mm(){
//我们也可以使用一个常量对象作为锁对象
synchronized (obj){
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}
}
静态方法也可以实现
public class Text03 {
public static void main(String[] args) {
//创建两个线程分别调用mm方法
//先创建Test实例对象通过对象名调用对象
Text03 test01 = new Text03();
Text03 test02 = new Text03();
//启动第一个线程
new Thread(new Runnable() {
@Override
public void run() {
Text03.sm();
}
}).start();
//启动第二个线程
new Thread(new Runnable() {
@Override
public void run() {
Text03.sm();
}
}).start();
}
public static final Object obj =new Object();
public static void sm(){
//我们也可以使用一个常量对象作为锁对象
synchronized (obj){
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}
}
一个线程先打印一百行,另一个线程再打印
同步实例方法
public class Text04 {
public static void main(String[] args) {
//创建两个线程分别调用mm方法
//先创建Test实例对象通过对象名调用对象
Text04 test01 = new Text04();
//启动第一个线程
new Thread(new Runnable() {
@Override
public void run() {
test01.mm();
}
}).start();
//启动第二个线程
new Thread(new Runnable() {
@Override
public void run() {
test01.mm2();
}
}).start();
}
//定义一个方法打印一百行字符串
public void mm(){
//我们通常使用this 即当前对象作为锁对象
synchronized (this){
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}
//定义一个方法打印一百行字符串
//使用synchronized修飾实例方法,同步实例方法,默认this为锁对象
public synchronized void mm2() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
同步静态方法
public class Text05 {
public static void main(String[] args) {
//创建两个线程分别调用mm方法
//先创建Test实例对象通过对象名调用对象
Text05 test01 = new Text05();
Text05 test02 = new Text05();
//启动第一个线程
new Thread(new Runnable() {
@Override
public void run() {
test01.mm();
}
}).start();
//启动第二个线程
new Thread(new Runnable() {
@Override
public void run() {
test02.mm2();
}
}).start();
//启动第三个线程
new Thread(new Runnable() {
@Override
public void run() {
Text05.mm2();
}
}).start();
}
//定义一个方法打印一百行字符串
public static void mm(){
//我们通常使用this 即当前对象作为锁对象
synchronized (Text05.class){
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}
//定义一个方法打印一百行字符串
//使用synchronized修飾静态方法,同步静态方法,默认运行时类为锁对象
public static synchronized void mm2() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}