首页 / JAVA / Java多线程(一)——线程基础和锁锁锁

Java多线程(一)——线程基础和锁锁锁

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java多线程(一)——线程基础和锁锁锁，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6631字，纯文字阅读大概需要10分钟。

内容图文

目录

Java多线程(一)

一、线程的定义

一个程序中不同的分支进行执行

二、Synchronize线程同步

概念：线程同步指的是，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作。

多线程访问同一个资源会产生线程安全问题，所以需要进行加锁。

package com.littlepage.test;

class MyThread implements Runnable{
    //票数是多个线程的共享资源
    private int ticket = 10;
    @Override
    public void run() {
        while(ticket > 0)
        {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"还剩下"+ticket--+"张票");
        }
    }
}
public class Test {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        new Thread(thread1,"黄牛A").start();
        new Thread(thread1,"黄牛B").start();
        new Thread(thread1,"黄牛C").start();
    }
}

多运行几次，发现出现了负数

Java多线程(一)——线程基础和锁锁锁 - 文章图片

这就是线程安全问题，为了解决这个问题，我们采用加锁进行控制

@Override
    public synchronized void run() {
        while(ticket > 0)
        {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"还剩下"+ticket--+"张票");
        }
    }

增加了一个锁之后，打印结果为

Java多线程(一)——线程基础和锁锁锁 - 文章图片

我们在方法上加synchronize，实际上等同下面这个写法

class MyThread implements Runnable{
    //票数是多个线程的共享资源
    private int ticket = 10;
    @Override
    public void run() {
        synchronized (MyThread.class) {
            while(ticket > 0)
            {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"还剩下"+ticket--+"张票");
            }
        }
    }
}

这个MyThread.class是一个互斥锁(mutex)，C程序中，我们mutex的实现是，指定一个信号量，对其进行pv操作实现锁机制，Java中的对象锁，深纠底层，原理是锁是存在对象头里面的，什么是Java对象头？Java对象头是一个与对象本身无关的一个额外区域，我们在使用锁的时候，实际上对Java对象头内部指针进行了操作。

三、偏向锁、自旋锁、重量级锁

  • Java在使用synchronize关键字，首先在Java对象头进行markword，记录这个线程id，只有一个线程对这个对象加锁，这个锁叫做偏向锁。
  • 偏向锁如果有线程争用，那么升级为自旋锁？一个锁如果被使用，那么另外一个线程打算争抢这把锁，则会陷入while循环，形成自旋。这叫做自旋锁。
  • 旋10次之后，升级为重量级锁。重量级锁以OS为主体。那么重量级锁不会占用CPU。
  • 注：锁不能降级

四、volatile关键字

4.1.普通变量运算的物理意义

一般程序来说，我们定义一个a ，使用a++进行操作，在物理上，实际是将a放入高速缓存（cache），经过运算后，再放回内存，这样就出现线程安全问题，几个线程同时进行a++操作，可能没有达到最终加值效果。在比如是类似银行汇款的业务中，那么问题就出来了。

4.2.有无解决的方案

volatile关键字，在Java语言和C程序中都有，这个关键字可以硬性规定，先将变量加锁，使变量在主存中进行计算，之后再释放锁，所以，变量不会出现运算失误状态。

4.3.volatile的几个特性（参考https://www.cnblogs.com/kubidemanong/p/9505944.html）
  • 可见性

在多线程环境下，如果一个线程修改了，其他线程能立即读到。这是因为他们读取的时候不会先把变量读进自己的缓存，直接在内存读取

  • 缓存一致性协议

线程中处理器一直在总线上进行查看进行探测情况，一旦发现其他处理器要修改这个内存地址的值，那么，就让自己的高速缓存区变为无效状态，从内存进行读取

  • 有序型
int a=1;
int b=2;

我们写完这个话后，因为无论执行哪句话都没影响，所以，虚拟机会对这两句指令进行重排序、

所以，我们可以使用volatile保证有序

重排序会遇到线程安全问题

五、Compare And Swap无锁自旋优化技术和ABA版本号机制

5.1.CAS操作原理

CAS操作：CAS存在3个参数，变量V，旧值A，新值B，内存值与B相等的时候，才会去修改B，否则直接返回。

CAS是一种CPU原语。

cas(V,Expected,NewValue)
if V==E
E=New
otherwise try again or fail
-CPU对原语支持

java.util.concurrent.atomic下有很多CAS操作的类

5.2.atomic包

例如AtomicInteger，这个对象调用incrementAndGet方法，和int a=0;a++;不一样，这个是线程安全的，无论起多少个线程，都能在无锁状态进行线程安全操作。在旧版本Java中，没有偏向，自旋，重量级升级说吧的概念，所以AtomicInteger速度会比synchronize快很多，因为是无锁操作。现在来讲，速度应该差不多。

 public static void main(String[] args){
    AtomicInteger count = new AtomicInteger(0);
    for(int i=0;i<1000;i++) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                count.incrementAndGet();
            }
        });
    }
}

包内其他对象

Java多线程(一)——线程基础和锁锁锁 - 文章图片

5.3.关于大并发下AtomicInteger和LongAdder和Sync的效率（百万并发以上）

Java多线程(一)——线程基础和锁锁锁 - 文章图片

5.4.版本号机制（参考https://blog.csdn.net/qq_34337272/article/details/81072874）

一般是在数据表中加上一个数据版本号version字段，表示数据被修改的次数，当数据被修改时，version值会加一。当线程A要更新数据值时，在读取数据的同时也会读取version值，在提交更新时，若刚才读取到的version值为当前数据库中的version值相等时才更新，否则重试更新操作，直到更新成功。

5.5.ABA问题（参考https://blog.csdn.net/qq_34337272/article/details/81072874）

如果一个变量V初次读取的时候是A值，并且在准备赋值的时候检查到它仍然是A值，那我们就能说明它的值没有被其他线程修改过了吗？很明显是不能的，因为在这段时间它的值可能被改为其他值，然后又改回A，那CAS操作就会误认为它从来没有被修改过。这个问题被称为CAS操作的 "ABA"问题。

JDK 1.5 以后的 AtomicStampedReference 类就提供了此种能力，其中的 compareAndSet 方法就是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

六、乐观锁和悲观锁（参考https://blog.csdn.net/qq_34337272/article/details/81072874）

  • 乐观锁

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

  • 悲观锁

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

七、公平锁、非公平锁

7.1.概念

公平锁：加锁之前先检查是否有排队等待的线程，有的话优先处理排前面的线程，先来先得。

非公平锁：线程加锁时直接尝试获取，获取不到就到队尾等待

7.2.Java中的公平锁和非公平锁

//非公平锁
Lock nonFairLock=new ReentrantLock(true);//默认空参是true
//公平锁
Lock fairLock=new ReentrantLock(false);

注：非公平锁比公平锁快很多

7.3.重入锁

ReetranLock含义是重入锁，什么意思呢，可以进行加锁多次，和解锁多次，比如

public class NoVisibility{
    public static void main(String[] args){
        Lock lock=new ReentrantLock();
        lock.lock();
        lock.lock();
        lock.unlock();
        lock.unlock();
    }
}

内容总结

以上是互联网集市为您收集整理的Java多线程(一)——线程基础和锁锁锁全部内容，希望文章能够帮你解决Java多线程(一)——线程基础和锁锁锁所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/692490.html

来源：【匿名】