java编程基础总结——30.synchronized和Lock锁解决线程安全问题

最新推荐文章于 2024-03-05 22:01:54 发布

m0_58679504

最新推荐文章于 2024-03-05 22:01:54 发布

阅读量229

点赞数

文章标签： java

本文链接：https://blog.csdn.net/m0_58679504/article/details/126350188

版权

引入：继承Thread和实现Runable的区别：

继承Thread：

package com.openlab.multithreading;

public class TestThread03 extends Thread {

    private int count;

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            count++;
        }
        System.out.println(Thread.currentThread().getName()+ "：count = "+ count);
    }

    public static void main(String[] args) {
        TestThread03 task1 = new TestThread03();
        TestThread03 task2 = new TestThread03();
        task1.start();
        task2.start();
    }
}

实现Runable：

使用不同的Thread对象启动同一个Runable线程对象（按照操作系统来说，线程应该共享同一个进程内的内存数据）

package com.openlab.multithreading;

public class TestThread04 implements Runnable {

	private int count;

	@Override
	public void run() {// synchronized
		for (int i = 0; i < 10000; i++) {
			count++;
		}
		System.out.println(Thread.currentThread().getName() + "：count = " + count);
	}

	public static void main(String[] args) {
		TestThread04 task = new TestThread04();
		new Thread(task).start();
		new Thread(task).start();

	}
}

注意：如果实现Runable接口中的代码这样写，就和Thread一样了

TestThread04 task = new TestThread04();
TestThread04 task02 = new TestThread04();
new Thread(task).start();
new Thread(task02).start();

继承Thread和实现Runable区别：

继承Thread的线程对象之间不能共享数据。如qq不可能访问到微信上的数据

实现Runable线程对象，如果使用不同的Thread对象启动同一个Runable线程对象，则会共享内存数据。
这种现象，可能会出现线程安全问题。

线程安全问题：多个线程同时操作同一个共享资源的时候可能会出现业务安全问题

用不同的Thread对象启动同一个Runable线程对象出现各种结果的原因：

++ -- 不具备原子性

例子：

左边加到21，还没赋回去，就被右边抢走了，右边拿到的就是20

右边加到2000，被左边抢走了，根据内存屏障原理，左边不知道值已经变成了2000，左边会把上次的21赋回去。此时，瞬间由2000-->21，少了很多值

如何解决线程安全问题：
通过加锁解决

一、synchronized关键字

关键字

java提供了同步锁，synchronized，该锁有三种使用方式
       1、同步块
       2、将方法加锁
       3、将静态方法加锁

该锁必须使用一个对象作为钥匙！！！

java的锁的问题：

synchronized关键字：
   是同步锁，关键字
   加锁的时候，范围越小越好

synchronized使用方式有三种：

1、同步块

key必须是一个对象
       synchronized(key) {
           // 同步代码
       }

访问到此块时，拿到key的才会进入，其他的会被阻塞，形成一个队列，等待当前拿到钥匙的去释放锁，等到执行完了，释放了，第二个抢到key的线程才会进来


public class TestSynchronized extends Thread {

    private int count;
    Object obj = new Object();

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            synchronized (obj) {
                count++;
            }
        }
        System.out.println(Thread.currentThread().getName()+ "：count = "+ count);
    }

    public static void main(String[] args) {
        TestSynchronized task = new TestSynchronized();
        new Thread(task).start();
        new Thread(task).start();

    }
}

第二个线程始终是2000

2、普通方法上面加

如果某个方法都是有可能出现线程安全问题
则建议加载方法上面
该方法在充当锁的钥匙！！！(key，java中的函数本质就是对象)

public class TestSynchronized extends Thread {

    private int count;

    @Override
    public  synchronized void run() {
        for (int i = 0; i < 10000; i++) {
                count++;
        }
        System.out.println(Thread.currentThread().getName()+ "：count = "+ count);
    }

    public static void main(String[] args) {
        TestSynchronized task = new TestSynchronized();
        new Thread(task).start();
        new Thread(task).start();

    }
}

当某个线程进入这个方法，其他线程就不可能进来，只有等这个线程执行完其他才能进来，所以并发度很差，肯定不会出现线程安全问题

3、静态方法上面

当前静态方法所属的静态类（类的字节码对象）在充当锁的钥匙！！！

public class TestSynchronized extends Thread {

	private static int count;

	@Override
	public void run() {
		test();
	}

	public synchronized static void test() {
		for (int i = 0; i < 10000; i++) {
			count++;
		}
		System.out.println(Thread.currentThread().getName() + "：count = " + count);
	}

	public static void main(String[] args) {
		TestSynchronized task = new TestSynchronized();
		new Thread(task).start();
		new Thread(task).start();

	}
}

因为static拿到的是类的字节码对象，所以我们也可以通过类名.class 拿到当前类的字节码对象

public class TestSynchronized extends Thread {

	private static int count;

	@Override
	public void run() {
		for (int i = 0; i < 10000; i++) {
			synchronized (TestSynchronized.class) {
				count++;
			}
		}
		System.out.println(Thread.currentThread().getName() + "：count = " + count);
	}

	public static void main(String[] args) {
		TestSynchronized task = new TestSynchronized();
		new Thread(task).start();
		new Thread(task).start();

	}
}

synchronized同步锁在jdk7之前，默认调用系统锁（重量级锁）
基于如上原因，jdk5，JUC包诞生，提供了一种全新的锁——Lock锁

二、Lock锁：

对象

lock 是一个接口，所以肯定需要利用它的实现子类，这里利用ReentrantLock
lock锁，是jdk5.0提供的锁、是一个可重入锁（ReentrantLock）
可以充当公平锁、也可以是不公平锁。（默认非公平锁，但是构造函数中可以传boolean值进行修改）

在什么地方出现并发，就在什么地方前一行加锁
一旦加锁，最后必须释放该锁，否则会出现死锁现象。
将释放锁的代码一定要放在finally中！！！

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

public class TestLock extends Thread {

    private int count;
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            try {
                // 加锁
                lock.lock();
                count++;

            } finally {
                // 一定要记得释放锁！！
                // 建议将释放锁的代码一定要放在finally中！！！
                lock.unlock();
            }
        }
        System.out.println(Thread.currentThread().getName()+ "：count = "+ count);
    }

    public static void main(String[] args) {
        TestLock task = new TestLock();
        new Thread(task).start();
        new Thread(task).start();

    }
}