Day9 尚硅谷JUC——Lock接口

最新推荐文章于 2024-05-16 10:23:10 发布

夢想家吖

最新推荐文章于 2024-05-16 10:23:10 发布

阅读量240

点赞数 1

分类专栏： JUC 文章标签： java jvm 数据结构

本文链接：https://blog.csdn.net/qq2632246528/article/details/126923680

版权

JUC 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

我是大白(●—●)，这是我开始学习记录大白Java软件攻城狮晋升之路的第九天（补）。今天学习的是【尚硅谷】大厂必备技术之JUC并发编程

文章目录

一、Synchronized
二、什么是Lock接口
三、创建线程的多种方式

一、Synchronized

1. Synchronized作用范围

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种:

修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{ }括起来的代码，作用的对象是调用这个代码块的对象；
修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized 关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。·

修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
修饰一个类，其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象。

2. Synchronized实现卖票的例子

多线程的编程步骤：

第一步创建资源类，在资源类创建属性和操作方法
第二步创建多个线程，调用资源类的操作方法。

package com.example.demo;

/**
 * @author Administrator
 * 三个售票员卖30张票
 */

/**
 * 第一步：创建资源类，定义属性和操作方法
 */
class Ticket {
    private int number = 30;
    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出时票数：" + (number--) + " 剩下：" +number);
        }
    }
}

public class SaleTicket {
    //第二步：创建多个线程，调用资源类和操作方法
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.sale();
                }
            }
        }, "AA").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.sale();
                }
            }
        }, "BB").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.sale();
                }
            }
        }, "CC").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.sale();
                }
            }
        }, "DD").start();
    }
}

3. 线程调用start方法会立马创建线程么

答案是不一定，Thread线程类调用的start方法，但是底层调用的是start0()方法，是native修饰的，因此调用之后需要由操作系统的一系列指令后才可以创建

public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

    private native void start0();

二、什么是Lock接口

1. Lock接口介绍

Lock锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对象。Lock提供了比 synchronized更多的功能。

2. Lock与Synchronized的区别

Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个接口，通过这个接口的实现类可以实现同步访问；
采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized 代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动通过unLock()去释放锁，就有可能导致出现死锁现象。因此使用Lock 时需要在finally块中释放锁;
Lock可以让等待锁的线程响应中断，而synchronized 却不行，使用synchronized 时，等待的线程会一直等待下去，不能够响应中断；
Lock可以知道有没有成功获取锁，而synchronized 却无法办到。
Lock可以提高多个线程进行读操作的效率。

在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。

2. Lock锁实现卖票的例子

package com.example.demo;

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


class LTicket {
    private int number = 30;
    private final ReentrantLock lock = new ReentrantLock();

    public void sale() {
        lock.lock();
        try{
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出时票数：" + (number--) + " 剩下：" +number);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}
public class LSaleTicket {
    //第二步：创建多个线程，调用资源类和操作方法
    public static void main(String[] args) {
        LTicket ticket = new LTicket();
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        }, "AA").start();
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        }, "BB").start();
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        }, "CC").start();
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        }, "DD").start();
    }
}

3. 可重入锁

维基百科的解释：

若一个程序或子程序可以“在任意时刻被中断然后操作系统调度执行另外一段代码，这段代码又调用了该子程序不会出错”，则称其为可重入（reentrant或re-entrant）的。即当该子程序正在运行时，执行线程可以再次进入并执行它，仍然获得符合设计时预期的结果。与多线程并发执行的线程安全不同，可重入强调对单个线程执行时重新进入同一个子程序仍然是安全的。

通俗来说：当线程请求一个由其它线程持有的对象锁时，该线程会阻塞，而当线程请求由自己持有的对象锁时，如果该锁是重入锁，请求就会成功，否则阻塞。
再换句话说：可重入就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁。

三、创建线程的多种方式

继承Thread类
实现Runable接口，没有返回值，不抛出异常
实现Callable接口，有返回值，会抛出异常。这个返回值可以被Future 拿到，也就是Future 可以拿到异步执行任务的返回值，可以声明异常，需要以实现的callable接口的类为参数创建FutureTask对象，将FutureTask作为参数创建Thread对象；

class MyThread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + "*******************come in Callable");
        Thread.sleep(2000);
        return 1024;
    }
}

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> futureTask = new FutureTask<>(new MyThread());
        new Thread(futureTask, "AA").start();
        new Thread(futureTask, "BB").start();
        int result1 = 100;
        while (!futureTask.isDone()) {

        }
        //如果没有计算完成就要去强求，会导致阻塞，值得计算完成
        int result2 = futureTask.get();
        System.out.println("*****result: " +(result1 + result2));
    }
}

使用线程池的方法创建线程

ExecutorService threadPool = Executors.newFixedThreadPool(5); //一池5个处理线程
ExecutorService threadPool = Executors.newSingleThreadExecutor();//一池1个处理线程
ExecutorService threadPool = Executors.newCachedThreadPool(); //一池N个处理线程
try {
    for (int i = 0; i < 10; i++) {
        threadPool.execute(() -> {
            System.out.println(Thread.currentThread().getName() + "\t 办理业务");
        });
    }
}catch (Exception e) {
    e.printStackTrace();
} finally {
    threadPool.shutdown();
}

夢想家吖

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Day9 尚硅谷JUC——Lock接口

Lock锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对象。Lock提供了比 synchronized更多的功能。
复制链接

扫一扫