使用加锁类LOCK和synchronized关键字分别对线程进行加锁实例

使用加锁类LOCK和synchronized关键字分别对线程进行加锁实例

首先来个不使用加锁导致线程不安全的实例，ArrayList是线程不安全的，现在创建一个ArrayList对象，创建1000个线程，每个线程往这个ArrayList对象里面添加100个元素，这时候ArrayList的元素个数应该是1000*100=100000个，可是我们来看看结果是不是这样的呢？ 直接上代码如下：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class RunnableNo
{
    public static void main(String[] args)
    {
        // 进行10次测试
        for(int i = 0; i < 10; i++)
        {
            test();
        }
    }

    public static void test()
    {
        // 创建一个用来测试的List
        List<Object> list = new ArrayList<Object>();
        // 线程数量(1000)
        int threadCount = 1000;
        // 用来让主线程等待threadCount个子线程执行完毕，确保1000个子线程都执行完毕了程序才往下一步执行
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        // 启动threadCount=1000个子线程，每个线程都往list里面塞100个元素，这时候如果线程安全，list的元素个数应该是1000*100=100000个
        for(int i = 0; i < threadCount; i++)
        {
            Thread thread = new Thread(new MyThread(list, countDownLatch));
            thread.start();
        }
        try
        {
            //主线程等待所有子线程执行完成，再向下执行，也就是说等待1000个子线程都执行完毕了程序才往下一步走
            countDownLatch.await();
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        // 打印list集合的个数，按道理说应该是1000*100=100000个
        System.out.println(list.size());
    }
}

class MyThread implements Runnable
{
    private List<Object> list;

    private CountDownLatch countDownLatch;

    public MyThread(List<Object> list, CountDownLatch countDownLatch)
    {
        this.list = list;
        this.countDownLatch = countDownLatch;
    }
    
    public void run()
    {
		// 每个线程向List中添加100个元素
        for(int i = 0; i < 100; i++)
        {
            list.add(new Object());
        }
        // 完成一个子线程，
        countDownLatch.countDown();
    }
}

直接复制上面代码运行，运行可能报错，不要紧不是代码问题，多运行几次，我电脑比较垃圾运行了七八次才成功，我重复循环了十次，没有一次的结果是正确的100000个，来看下运行结果：

那这时候什么办呢？什么才能让我们的代码运行得到我们想要的结果呢？也就是100000个元素。那么这个时候就要用到了线程的加锁了synchronized关键字或者加锁类LOCK

①synchronized关键字加锁

将线程中可能造成线程不安全的代码用synchronized关键字进行修饰，代码还是上面那段代码，只是做了如下修改，下面是修改的部分：

这时候看看运行结果能不能得到我们想要的结果：

②加锁类LOCK进行加锁
同样的代码还是上面那一段代码，下面是修改部分的代码：

最后执行结果如下：

以上就是使用加锁类LOCK和synchronized关键字分别对线程进行加锁实例的全部内容， 加油码农们，每天都进步一点点，总有一天能成为大佬的…