java 锁的实现

最新推荐文章于 2022-01-08 09:18:29 发布
最新推荐文章于 2022-01-08 09:18:29 发布
阅读量149 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40117836/article/details/104185455
版权

多线程中的锁

自旋锁

在使用wait()和notify()来控制代码的执行时，可能会出现假唤醒的情况。

public class Demo{

    List<String> list = new ArrayList<>();

    public void push(String val){
        synchronized (this){
            list.add(val);
            notify();
        }
    }

    public void pop() throws InterruptedException {
        synchronized (this){
            if(list.size()<=0){
                wait();
            }
            list.remove(list.size()-1);
        }
    }
}

若有线程A、B、C

  1. 线程A首先进入pop()方法时，list的size()<=0,线程A阻塞。
  2. 线程B调用push()方法，list.size()=1，并且唤醒线程A的pop方法。
  3. 在线程A被唤醒执行后面的程序之前，线程C先调用pop()方法，此时的list.size()为1，则不用进入if判断，直接调用remove()方法，list.size()为0。
  4. 然后线程A直接调用remove()方法，但是此时的list.size()为0，程序报错。

为了解决假唤醒，需要将if改为while。这样的一个while循环叫做“自旋锁”

自旋锁是一种无锁状态，是通过不断比较来确保当前值没有被改变。本身cas的内部就是自旋锁。此处的demo并没有解决aba的问题。

ThreadLoacl

当多线程访问的同一个对象时，该对象的成员变量为所有线程共有。当某一个线程修改对象的成员变量时，会对其他线程造成影响。ThreadLocal类用来保证创建的变量在每个线程中独立存在，多个线程间互不影响。虽然不同的线程执行同一段代码时，访问同一个ThreadLocal变量，但是每个线程只能看到私有的ThreadLocal实例。所以不同的线程在给ThreadLocal对象设置不同的值时，他们也不能看到彼此的修改。

  • 使用map来保存变量
public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T(3);
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        t1.start();
        Thread.sleep(1000);
        t2.start();
    }
}

class T  implements Runnable{
    Map<String,Integer> map = new HashMap<>();
    int i;
    T(int i){
        this.i = i;
    }
    @Override
    public synchronized void run() {
        System.out.println(map.get("val"));
        map.put("val",i);
    }
}

输出结果：t1线程输出为null,而t2线程输出为3。
此时map在t1线程执行时被修改了，所以在t2线程访问map时，map中是有值的。

  • 使用ThreadLocal类来保存的变量
public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T(3);
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        t1.start();
        Thread.sleep(1000);
        t2.start();
    }
}

class T  implements Runnable{
    ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
    int i;
    T(int i){
        this.i = i;
    }
    @Override
    public synchronized void run() {
        System.out.println(threadLocal.get());
        threadLocal.set(i);
    }
}

输出结果：t1线程输出为null,t2线程输出也为null。
由于ThreadLoacl类中保存的变量为每个线程私有的，所以在t1线程中将ThreadLocal中设置值后，t2线程ThreadLocal时仍为null。

初始化ThreadLocal
重新ThreadLocal中的initialValue() 方法，就可以为ThreadLocal对象指定一个初始化值，并对所有的线程都可见。

public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T(3);
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        t1.start();
        Thread.sleep(1000);
        t2.start();
    }
}

class T  implements Runnable{
    ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>(){
    	//初始化ThreaLocal
        public Integer initialValue() {
            return 0;
        }
    };
    int i;
    T(int i){
        this.i = i;
    }
    @Override
    public synchronized void run() {
        System.out.println(threadLocal.get());
        threadLocal.set(i);
    }
}

输出结果：t1线程输出为0,t2线程输出也为0。

死锁

有A、B两线程，线程A在持有锁的同时想要获取线程B的锁。而此时线程B也同时持有锁并想要获取线程A的锁，这样的情况会导致两线程一直阻塞，造成死锁。

public class Demo3 {
    public static void main(String[] args) {
        Object a = new Object();
        Object b = new Object();
        T ta = new T(a,b);
        T tb = new T(b,a);
        //线程持有a的锁并想要获取b的锁
        new Thread(()->{ta.test();}).start();
        //线程持有b的锁并想要获取a的锁
        new Thread(()->{tb.test();}).start();
    }
}

class T{
    Object a;
    Object b;

    T(Object a, Object b){
        this.a = a;
        this.b = b;
    }

    public void test()  {
        synchronized (a){
            try {
            	System.out.println("~~~");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (b){
				System.out.println("...");
            }
        }
    }
}

使用jps查看java进程的情况如下：

14692 Demo3
1432 RemoteMavenServer
72 Launcher
10908 Jps
8716

使用jstack查看某个Java进程内的线程堆栈信息（这里要看Demo3线程情况，所以输入的是jstack 14692)。可以看出显示当前Thread-1和Thread-0为阻塞状态。

"Thread-1" #12 prio=5 os_prio=0 tid=0x0000000019872000 nid=0x36bc waiting for monitor entry [0x000000001a2af000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at t01.T.test(Demo3.java:32)
        - waiting to lock <0x00000000d5ebfe70> (a java.lang.Object)
        - locked <0x00000000d5ebfe80> (a java.lang.Object)
        at t01.Demo3.lambda$main$1(Demo3.java:10)
        at t01.Demo3$$Lambda$2/1096979270.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)

"Thread-0" #11 prio=5 os_prio=0 tid=0x0000000019888000 nid=0x3334 waiting for monitor entry [0x000000001a1af000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at t01.T.test(Demo3.java:32)
        - waiting to lock <0x00000000d5ebfe80> (a java.lang.Object)
        - locked <0x00000000d5ebfe70> (a java.lang.Object)
        at t01.Demo3.lambda$main$0(Demo3.java:9)
        at t01.Demo3$$Lambda$1/1324119927.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)

嵌套管程锁死

线程1获取A锁后又获取了B锁，却调用了B.wait()的方法去释放B锁，导致程序阻塞，无法释放A锁，需要线程2去唤醒。但线程2需要持有A锁，最终程序无法运行。

class MyLock{

   private Object o = new Object();
   private boolean isLock = false;

   public synchronized void lock() throws InterruptedException {
       while(isLock){
           synchronized (o){
               o.wait();
           }
       }
       isLock = true;
   }

   public synchronized void unLock(){
       isLock = false;
       o.notify();
   }
}

第一个线程调用lock()方法，在调用unLock()方法前，第二个线程调用了lock()方法，此时第二个线程处于等待状态。此时当一个线程准备调用unLock()方法时去唤醒第二个线程时，却无法获取当前对象的锁，导致程序阻塞。

公平锁

  当有多个线程需要获取同一把锁的时候，若其中一个线程获取，则其他线程被阻塞，等待锁的释放。当锁释放时，所有线程重新抢占这把锁，这样可能会出现一种情况，有一个线程总是无法获取到锁，导致线程处于饥饿状态。
  java中的synchronized是无法保证线程的公平性。java本身是无法实现百分百线程的公平性，但是可以提高线程的公平性。

  • 先实现一个普通的锁
public class Lock{

   private boolean isLock = false;

   private Thread thread = null;

   public synchronized void lock() throws InterruptedException {
       //自旋锁的写法
       while(isLock){
           System.out.println(Thread.currentThread().getName()+"等待");
           this.wait();
       }
       isLock = true;
       thread  = Thread.currentThread();
   }

   public synchronized void unLock(){
       System.out.println("唤醒");
       //防止同一线程多次调用unLock方法唤醒其他线程或是其他
       if(Thread.currentThread() != thread){
           throw new IllegalMonitorStateException();
       }
       isLock = false;
       thread = null;
       this.notify();
   }
}

当第一个线程调用lock() 方法时会将isLock 置为true，后续线程调用lock() 方法时，会进入while 判段，调用wait() 方法，释放锁。这样之后所有的线程都可以进入lock() 方法，然后在调用wait() 方法时阻塞。在第一个线程执行unlock() 方法后会唤醒其中的一个线程。

  • 出现嵌套管程锁死的公平锁
public class FairLock {
    private List<QueueThread> list = new ArrayList<>();
    private Thread lockThread = null;
    private boolean isLock = false;

    public void lock() throws InterruptedException {
        QueueThread queueThread = new QueueThread();
        synchronized (this){
            list.add(queueThread);
            while(isLock || queueThread != list.get(0)){
            	//这个synchronized(queueThread)加不加都一样，因为本身doWait()方法已经是一个同步方法，而且锁的时当前对象。这样是为了代码看起来更清晰
            	synchronized(queueThread){
					queueThread.doWait();
				}
            }
            isLock = true;
            lockThread = Thread.currentThread();
            list.remove(list.get(0));
        }
    }

    public synchronized void unLock(){
        if(Thread.currentThread() != lockThread){
            throw new RuntimeException();
        }
        lockThread = null;
        isLock = false;
        if(list.size()>0){
        	//这个同步代码块也是为了代码更清晰
        	synchronized(list.get(0)){
        		list.get(0).doNotify();
			}
        }
    }
}

class QueueThread{

    public synchronized void doWait() throws InterruptedException {
        this.wait();
    }

    public synchronized void doNotify(){
        this.notify();
    }
}

这个公平锁会出现嵌套管程锁死，当调用queueThread.doWait();方法时虽然会释放queueThread对象的锁，但是无法释放this这个锁，导致doNotify()方法无法获取锁，程序被阻塞。

  • 将嵌套的锁提取出来
public class FairLock {

    private List<QueueThread> list = new ArrayList<>();
    private boolean isLock = false;
    private Thread lockThread = null;

    public void lock() throws InterruptedException {
        QueueThread queueThread = new QueueThread();
        synchronized(this){
            list.add(queueThread);
        }
        while(isLock || queueThread != list.get(0)){
            synchronized (queueThread){
                queueThread.doWait();
            }
        }
        synchronized (this){
            isLock = true;
            lockThread = Thread.currentThread();
            list.remove(list.get(0));
        }
    }

    public synchronized void unLock(){
        if(Thread.currentThread() != lockThread){
            throw new RuntimeException();
        }
        isLock = false;
        if(list.size()>0){
            list.get(0).doNotify();
        }
    }
}

class QueueThread{

    public synchronized void doWait() throws InterruptedException {
        this.wait();
    }

    public synchronized void doNotify(){
        this.notify();
    }
}

这样的锁还是有一个缺点。当线程1调用lock()方法，线程2在执行完第一个同步代码块，进入while语句中的第二个同步代码块时，由于一个同步代码块执行完后，当前锁被释放，这时的线程1在线程2执行doWait()前执行了unLock()方法，这时的线程2再执行doWait()方法时会被阻塞，但是由于unLock()方法被调用了，所以就无法唤醒线程2的等待。
为了解决这个问题，需要在 QueueThread类中保存信号

  • 最终的公平锁
public class FairLock {

    private List<QueueThread> list = new ArrayList<>();
    private boolean isLock = false;
    private Thread lockThread = null;

    public void lock() throws InterruptedException {
        QueueThread queueThread = new QueueThread();
        synchronized(this){
            list.add(queueThread);
        }
        while(isLock || queueThread != list.get(0)){
            synchronized (queueThread){
                queueThread.doWait();
            }
        }
        synchronized (this){
            isLock = true;
            lockThread = Thread.currentThread();
            list.remove(list.get(0));
        }
    }

    public synchronized void unLock(){
        if(Thread.currentThread() != lockThread){
            throw new RuntimeException();
        }
        isLock = false;
        if(list.size()>0){
            list.get(0).doNotify();
        }
    }
}

class QueueThread{
    private boolean isLock = false;

    public synchronized void doWait() throws InterruptedException {
        while(isLock){
            this.wait();
        }
        isLock = true;
    }

    public synchronized void doNotify(){
        isLock = false;
        this.notify();
    }
}

可重入锁

一个线程在持有一个锁后，那么这个线程则可以进入其他持有这个锁的代码块。这就是可重入锁。例如：

class Test{
    public synchronized  void outer(){
        inner();
    }

    public synchronized void inner() {
    }
}
  • 之前写过的一个普通的锁
public class Lock{

   private boolean isLock = false;

   private Thread thread = null;

   public synchronized void lock() throws InterruptedException {
       //自旋锁的写法
       while(isLock){
           this.wait();
       }
       isLock = true;
       thread  = Thread.currentThread();
   }

   public synchronized void unLock(){
       //防止同一线程多次调用unLock方法唤醒其他线程或是其他
       if(Thread.currentThread() != thread){
           throw new IllegalMonitorStateException();
       }
       isLock = false;
       thread = null;
       this.notify();
   }
}

这种锁是不可重入的，但一个线程重复调用了lock()方法时，后面的线程会被阻塞。

  • 将这个锁改为可重入锁
public class Lock {

    private boolean isLock = false;
    private Thread thread;
    private int current = 0;

    public synchronized void lock() throws InterruptedException {
    	//使一个线程可以重复加锁
        while(isLock && thread != Thread.currentThread()){
            this.wait();
        }
        isLock = true;
        current++;
        thread = Thread.currentThread();
    }

    public synchronized  void unLock(){
        if(thread != Thread.currentThread()){
            throw new RuntimeException();
        }
        current--;
        if(current == 0){
            isLock = false;
            thread = null;
            this.notify();
        }
    }
}

读/写锁

当一个线程持有读锁时，这个线程无法再去获取写锁，但是可以获取读锁。
当一个线程持有写锁时，这个线程无法去获取写锁，也无法再获取读锁。

  • 一个不可重入的读写锁
public class ReadWriterLock {

    private boolean isReadLock = false;
    private boolean isWriterLock = false;
    private Thread writerThread = null;
    private int readCount = 0;

    public synchronized void readLock() throws InterruptedException {
        while(isWriterLock){
            wait();
        }
        readCount++;
        isReadLock = true;
    }

    public synchronized void unReadLock() throws InterruptedException {
        readCount--;
        if(readCount == 0){
            isReadLock = false;
            notifyAll();
        }
    }

    public synchronized void writerLock() throws InterruptedException {
        while(isReadLock || isWriterLock){
            wait();
        }
        isWriterLock = true;
        writerThread = Thread.currentThread();
    }

    public synchronized void unWriterLock(){
        if(writerThread != Thread.currentThread()){
            throw new RuntimeException();
        }
        isWriterLock = false;
        notifyAll();
    }
}

信号量

信号量是用来控制并发的数量，访问线程若超过所设置的信号量，则会被阻塞。

  • 一个简单信号量的实现
public class Semaphore {
    //当前信号量
    private int singles = 0;
    //最大信号量
    private int maxSingles = 10;

    public Semaphore(){}

    public Semaphore(int maxSingles){
        this.maxSingles = maxSingles;
    }

    //获取信号
    public synchronized void acquire() throws InterruptedException {
        while(singles == maxSingles){
            wait();
        }
        singles++;
        notify();
    }

    //释放信号
    public synchronized void release() throws InterruptedException {
        while (singles == 0){
            wait();
        }
        singles--;
        notify();
    }
}

乐观锁

乐观锁本身是非阻塞的，可以通过非阻塞算法来保证一致性。
如

class Demo{

    AtomicInteger count = new AtomicInteger();

    public void add(){
        boolean updated  = false;
        while(!updated){
            int temp = count.get();
            //如果更新失败则返回false，则会再次执行compareAndSet方法
            updated  = count.compareAndSet(temp,temp+1);
        }
    }
    
    public int get() {
        return count.get();
    }
}

compareAndSet方法会先去比较当前的值被是否改变，如果没有被改变则更新，否则不进行任何操作。

布莱恩铜须
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java锁升级的实现过程
08-19
Java 锁升级的实现过程 Java 锁升级是 Java 中的一种同步机制，用于解决多线程并发访问共享资源的问题。 Java 锁升级的实现过程可以分为三个阶段：偏向锁、轻量级锁和重量级锁。 对象内存布局 在 Java 中，对象在...
Java 读写锁实现原理浅析
08-27
"Java 读写锁实现原理浅析" Java 读写锁实现原理浅析是 Java 并发编程中一个非常重要的主题。在多线程编程中，读写锁是解决读写并发问题的常用机制。本文主要介绍了 Java 读写锁实现原理浅析，包括读写锁的定义、...
java读写锁锁变量_Java中读写锁的设计以及实现
weixin_31741827的博客
02-17 288
针对读多写少的场景，Java提供了另外一个实现Lock接口的读写锁ReentrantReadWriteLock(RRW),之前分析过ReentrantLock是一个独占锁，同一时间只允许一个线程访问。而 RRW 允许多个读线程同时访问，但不允许写线程和读线程、写线程和写线程同时访问。读写锁内部维护了两个锁，一个是用于读操作的ReadLock，一个是用于写操作的 WriteLock。读写锁遵守以下三...
java锁实现方式有哪些_5.Java中的锁的使用和实现介绍
weixin_34008968的博客
02-17 656
Java并发编程的艺术笔记目录Lock接口队列同步器重入锁读写锁LockSupport工具Condition接口小结Lock接口在Java SE 5之后，并发包中新增了Lock接口(以及相关实现类)用来实现锁功能，它提供了与synchronized关键字类似的同步功能，只是在使用时需要 显式 地获取和释放锁。虽然它缺少了(通过synchronized块或者方法所提供的)隐式获取释放锁的便捷性，但是...
JPA 乐观锁教程
neweastsun的专栏
09-02 3223
JPA 乐观锁 在企业级应用中，管理对数据库资源的并发访问至关重要。这意味着我们应该能够以一种有效且最重要防错方式处理多个事务。 更重要的是，我们需要确保数据在并发读取和更新时的一致性。为此，我们可以使用Java Persistence API提供的乐观锁机制。其实现同一时间对同一数据进行多次更新不会相互干扰。 理解乐观锁 乐观锁是不是数据库提供的机制。这里通过在实体中增加一个带有@V...
使用JPA实现乐观锁
徐靖峰的专栏
01-30 1万+
乐观锁的概念就不再赘述了，不了解的朋友请自行百度谷歌之，今天主要说的是在项目中如何使用乐观锁，做成一个小demo。持久层使用jpa时，默认提供了一个注解@Version先看看源码怎么描述这个注解的/** * Specifies the version field or property of an entity class that * serves as its optimistic lock
Java 锁系列（三）——ReentrantLock源码分析
玖涯博客
10-18 316
一、ReentrantLock 概述 ReentrantLock 是一个可重入的独占锁，是基于 AQS（AbstractQueuedSynchronized，抽象队列式同步器）实现的，它有公平锁和不公平锁两种实现方式。简单查看源码，可以发现 ReentrantLock 其实是一个代理的模式，Reentranlock 的核心是其内部继承自 AbstractQueuedSynchronized 的抽象类 Sync，将 Sync 作为锁的同步基础，其中加锁/解锁等操作其实都是由 Sync 对象完成的，也是通过实例
Java－分布式锁的实现方式
热门推荐
了解➔熟悉➔掌握➔精通
01-08 2万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请轻击http://www.captainbed.net 分布式锁的三种实现方式： 基于数据库实现分布式锁； 基于缓存（Redis等）实现分布式锁； 基于Zookeeper实现分布式锁。 一、基于数据库实现分布式锁 1、悲观锁 利用 select … where … for update 排他锁。 注意：其他附加功能与实现基本一致，这里需要注意的是“where name=lock”，name字段必须要走索
java乐观锁原理与实现案例分析
08-25
在上面的示例中，使用java乐观锁实现自动派单功能，检查是否已经被更新，如果已经被更新，则重新获取数据，直到没有冲突。 java乐观锁是一种高效的并发控制机制，适合并发冲突几率小的场景，例如，自动派单功能。...
Java Redis分布式锁的正确实现方式详解
08-25
Java Redis分布式锁的正确实现方式详解 Java Redis分布式锁是指使用Redis实现的分布式锁机制，旨在解决分布式系统中的并发问题。分布式锁有三种实现方式：数据库乐观锁、基于Redis的分布式锁和基于ZooKeeper的...
通过实例解析Java分布式锁三种实现方法
08-18
Java分布式锁三种实现方法 Java分布式锁是指在分布式系统中，为了避免多个节点同时操作同一个资源而造成的数据不一致和安全问题，需要使用分布式锁来保护共享资源。分布式锁可以分为三种实现方法：基于数据库实现...
使用 JPA 实现乐观锁
lizhengyu891231的博客
06-29 430
转载自：https://www.cnkirito.moe/jpa-OptimisticLock/ 叙述 乐观锁的概念就不再赘述了，不了解的朋友请自行百度谷歌之，今天主要说的是在项目中如何使用乐观锁，做成一个小 demo。 解决方案 持久层使用 jpa 时，默认提供了一个注解@Version先看看源码怎么描述这个注解的 @Target({METHOD, FIELD}) @Retention(RUNTIME) public @interface Version { } 简单来说就是用一个 ve..
java 实现队列读写锁_java锁（7）改进读写锁StampedLock详解
weixin_35043838的博客
02-16 355
1、StampedLock特性StampedLock是JDK 8新增的读写锁，跟读写锁不同，它并不是由AQS实现的。它的state为一个long型变量，状态的设计也不同于读写锁，且提供了三种模式来控制 read/write 的获取，并且内部实现了自己的同步等待队列。1.1、StampedLock读写锁写锁：使用writeLock方法获取，当锁不可用时会阻塞，获取成功后返回一个与这个写锁对应的sta...
java线程锁的状态_Java-synchronized 中锁的状态及其转换
weixin_29823011的博客
02-13 420
synchronized锁的优化过程：无锁 ->偏向锁 -> 轻量级锁 -> 重量级锁一、不同锁对象的状态表示(需要了解 Java 对象头)二、关于Lock Record(锁记录)当字节码解释器执行 monitorenter 字节码轻量级锁锁住一个对象时，就会在获取锁的线程的栈上显式或者隐式分配一个 Lock Record 空间。三、偏向锁在 JDK 1.6 中引入，默认启...
人力资源+大数据+薪酬报告+涨薪调薪，在学习、工作生活中，越来越多的事务都会使用到报告，通常情况下，报告的内容含量大、篇幅较长
08-12
人力资源+大数据+薪酬报告+涨薪调薪，在学习、工作生活中，越来越多的事务都会使用到报告，通常情况下，报告的内容含量大、篇幅较长。那么什么样的薪酬报告才是有效的呢？以下是小编精心整理的调薪申请报告，欢迎大家分享。相信老板看到这样的报告，一定会考虑涨薪的哦。
SEQ投诉处理与VONR信令及特性介绍
08-12
SEQ平台5G分析模块介绍 投诉分析处理 VoNR信令及特性介绍
毕业设计php企业进销存管理系统-qkrp源码含文档工具包
最新发布
08-12
毕业设计php企业进销存管理系统-qkrp源码含文档工具包 php，数据库mysql，jdk1.8，开发工具用ecplise、myecplise、sts、idea都可以 类型管理 商品管理 库存查看 库存查看 入库查看 出库查看 用户管理 包含：源码、数据库脚本、论文、环境工具包、相同框架项目的安装教程（在说明文档中）
大学生电子设计大赛-《高频电子线路》实验指导书.rar
08-12
大学生电子设计大赛-《高频电子线路》实验指导书.rar
XGBoost深度解析：梯度提升树的极致优化
08-12
机器学习是人工智能的一个分支，它使计算机系统能够从数据中学习并做出决策或预测，而无需进行明确的编程。机器学习算法可以分析大量数据，识别模式和趋势，并根据这些模式做出预测或决策。它包括几种不同的方法，包括： 1. **监督学习**：算法从标记的训练数据中学习，以便对新的输入数据进行分类或预测。 2. **无监督学习**：算法尝试在没有标记的训练数据中找到模式或结构。 3. **半监督学习**：结合了监督学习和无监督学习的方法，使用少量标记数据和大量未标记数据。 4. **强化学习**：算法通过与环境交互来学习，目标是最大化某种累积奖励。 机器学习在许多领域都有应用，包括图像识别、自然语言处理、医疗诊断、股市分析、自动驾驶车辆等。随着技术的发展，机器学习正变得越来越重要，并在不断扩展其应用范围。
AQS源码解析：Java锁实现深度剖析
"AQS源码分析"是一份深入研究Java锁底层实现的关键文档，主要关注的是AbstractQueuedSynchronizer（AQS）类的内部工作机制。AQS是Java并发库中的一个重要组件，它提供了一个模板用于同步器的设计，许多Java内置的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值