Jevely
Jevely

简单聊聊 Java ReentrantLock

大家好，这次我们来聊聊Java线程中ReentrantLock的使用，ReentrantLock和synchronized有相同的作用，都可以保证线程的安全性，但是ReentrantLock的功能更加的强大，费话不多少，下面我们正式开始。

ReentrantLock

我们先来介绍这篇文章的的一个关键类ReentrantLock，先看看是如何使用的：

public class LockTool {

    private ReentrantLock lock = new ReentrantLock();

    public void test() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " in test");
            Thread.sleep(2000);
            lock.unlock();
            System.out.println(Thread.currentThread().getName() + " out test");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class lockmain {

    public static void main(String[] args) {

        LockTool tool = new LockTool();
        for (int i = 0; i < 5; i++) {
            ThreadA threadA = new ThreadA(tool);
            threadA.start();
        }
    }

    public static class ThreadA extends Thread {

        private LockTool lockTool;

        public ThreadA(LockTool lockTool) {
            this.lockTool = lockTool;
        }

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

结果为：

Thread-0 in test
Thread-0 out test
Thread-1 in test
Thread-1 out test
Thread-2 in test
Thread-2 out test
Thread-3 in test
Thread-3 out test
Thread-4 in test
Thread-4 out test

我们可以看到线程都是按顺序执行的，它和synchronized的作用一样，但是它更加的强大，下面我们来慢慢了解。

Condition

在前面的的文章中，我们知道synchronized,wait(),notify()和notifyAll()方法结合使用可以实现线程同步以及通信的功能，然而ReentrantLock和Condition一起使用同样可以实现上面所说的功能，下面我们来看看代码：

public class LockTool {

    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void test() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " " + System.currentTimeMillis());
            condition.await();
            lock.unlock();
            System.out.println(Thread.currentThread().getName() + " " + System.currentTimeMillis());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void test2() {
        lock.lock();
        condition.signal();
        lock.unlock();
    }
}

public class lockmain {

    public static void main(String[] args) {
        try {
            LockTool tool = new LockTool();
            ThreadA threadA = new ThreadA(tool);
            threadA.start();
            Thread.sleep(3000);
            tool.test2();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static class ThreadA extends Thread {

        private LockTool lockTool;

        public ThreadA(LockTool lockTool) {
            this.lockTool = lockTool;
        }

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

结果为：

Thread-0 1566178593185
Thread-0 1566178596190

看结果我们发现线程在调用await方法过后处于阻塞状态，直到我们调用signal方法后，线程才继续执行，这里和wait()，notify()方法很相似。

公平锁和非公平锁

ReentrantLock在使用的时候也可以分为公平锁和非公平锁，公平锁的意思是线程在获取锁顺序是按照线程加锁的顺序，先加锁的线程就会现获取锁。而非公平锁的意思是线程获取锁的顺序是随机的，和线程加锁的顺序并没有关系，这样就有可能造成一些线程一直无法获取锁，这就是非公平锁。下面我们通过代码来看看：

public class LockTool {

    //这里的true为公平锁
    private ReentrantLock lock = new ReentrantLock(true);

    public void test() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "获取锁");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public class lockmain {

    public static void main(String[] args) {
        LockTool lockTool = new LockTool();
        List list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(new ThreadA(lockTool));
        }

        for (int i = 0; i < 10; i++) {
            list.get(i).start();
        }
    }

    public static class ThreadA extends Thread {

        private LockTool lockTool;

        public ThreadA(LockTool lockTool) {
            this.lockTool = lockTool;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "运行");
            lockTool.test();
        }
    }
}

结果为：

Thread-0运行
Thread-0获取锁
Thread-1运行
Thread-1获取锁
Thread-2运行
Thread-2获取锁
Thread-3运行
Thread-3获取锁
Thread-4运行
Thread-4获取锁
Thread-5运行
Thread-5获取锁
Thread-6运行
Thread-7运行
Thread-6获取锁
Thread-7获取锁
Thread-8运行
Thread-8获取锁
Thread-9运行
Thread-9获取锁

线程的执行顺序是有序。
我们将公平锁修改为非公平锁，在看看代码：

    private ReentrantLock lock = new ReentrantLock(false);

结果为：

Thread-0运行
Thread-2运行
Thread-0获取锁
Thread-3运行
Thread-3获取锁
Thread-1运行
Thread-2获取锁
Thread-4运行
Thread-4获取锁
Thread-1获取锁
......

当设置成非公平锁的时候，就有可能出现随机获取锁的情况。

getHoldCount()

getHoldCount()方法意思是获取当前线程保持此锁锁定的个数，下面我们用代码来演示一下：

public class LockTool {

    //这里的true为公平锁
    private ReentrantLock lock = new ReentrantLock();

    public void test1() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "获取锁1 总共获取锁个数为:" + lock.getHoldCount());
            test2();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    private void test2() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "获取锁2 总共获取锁个数为:" + lock.getHoldCount());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public class lockmain {

    public static void main(String[] args) {
        LockTool tool = new LockTool();
        ThreadA threadA = new ThreadA(tool);
        threadA.start();
    }

    public static class ThreadA extends Thread {

        private LockTool lockTool;

        public ThreadA(LockTool lockTool) {
            this.lockTool = lockTool;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "运行");
            lockTool.test1();
        }
    }
}

结果为：

Thread-0运行
Thread-0获取锁1 总共获取锁个数为:1
Thread-0获取锁2 总共获取锁个数为:2

getQueueLength()

getQueueLength()方法是获取正在等在次锁的线程个数，下面看一个例子：

public class LockTool {

    public ReentrantLock lock = new ReentrantLock();

    public void test() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "获取锁");
            Thread.sleep(10000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public class lockmain {

    public static void main(String[] args) {
        try {
            LockTool tool = new LockTool();
            for (int i = 0; i < 5; i++) {
                ThreadA threadA = new ThreadA(tool);
                threadA.start();
            }
            Thread.sleep(2000);
            System.out.println("等待线程个数为:" + tool.lock.getQueueLength());
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static class ThreadA extends Thread {

        private LockTool lockTool;

        public ThreadA(LockTool lockTool) {
            this.lockTool = lockTool;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "运行");
            lockTool.test();
        }
    }
}

结果为：

Thread-0运行
Thread-0获取锁
Thread-1运行
Thread-2运行
Thread-3运行
Thread-4运行
等待线程个数为:4

我们可以看到5个线程，1个获取了锁，等待此锁的就是4个线程。

getWaitQueueLength()

getWaitQueueLength()方法的作用是获取同一个Condition调用了await方法，并且正在阻塞的线程个数，下面我们来看看代码：

public class LockTool {

    public ReentrantLock lock = new ReentrantLock();
    public Condition condition = lock.newCondition();

    public void test() {
        try {
            lock.lock();
            condition.await();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void show() {
        lock.lock();
        System.out.println("同一个condition等待线程为:" +
                lock.getWaitQueueLength(condition));
        lock.unlock();
    }
}

public class lockmain {

    public static void main(String[] args) {
        try {
            LockTool tool = new LockTool();
            for (int i = 0; i < 6; i++) {
                ThreadA threadA = new ThreadA(tool);
                threadA.start();
            }
            Thread.sleep(2000);
            tool.show();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static class ThreadA extends Thread {

        private LockTool lockTool;

        public ThreadA(LockTool lockTool) {
            this.lockTool = lockTool;
        }

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

结果为：

同一个condition等待线程为:6

hasQueueThread()/hasQueueThreads()

hasQueueThread()意思是查询当前线程是否在等待此锁，hasQueueThreads()意思是查询是否有线程在等待此锁，下面我们看看代码：

public class LockTool {

    public ReentrantLock lock = new ReentrantLock();

    public void test() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "获取锁");
            Thread.sleep(10000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void show(Thread thread) {
        System.out.println(thread.getName() + "是否等待:" + lock.hasQueuedThread(thread));
        System.out.println("是否有线程等待:" + lock.hasQueuedThreads());
    }
}

public class lockmain {

    public static void main(String[] args) {
        try {
            LockTool tool = new LockTool();
            ThreadA threadA = new ThreadA(tool);
            threadA.setName("A");
            ThreadB threadB = new ThreadB(tool);
            threadB.setName("B");
            threadA.start();
            threadB.start();
            Thread.sleep(2000);
            tool.show(threadB);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static class ThreadA extends Thread {

        private LockTool lockTool;

        public ThreadA(LockTool lockTool) {
            this.lockTool = lockTool;
        }

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

    public static class ThreadB extends Thread {

        private LockTool lockTool;

        public ThreadB(LockTool lockTool) {
            this.lockTool = lockTool;
        }

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

结果为：

A获取锁
B是否等待:true
是否有线程等待:true

hasWaiters()

hasWaiters()方法是获取是否有线程正在等待有相同Condition的线程释放阻塞，下面我们看看代码：

public class LockTool {

    public ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void test() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "获取锁");
            condition.await();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        System.out.println(Thread.currentThread().getName() + "完成");
    }

    public void show() {
        lock.lock();
        System.out.println("是否有线程正在等待:" + lock.hasWaiters(condition));
        lock.unlock();
    }
}

public class lockmain {

    public static void main(String[] args) {
        try {
            LockTool tool = new LockTool();
            ThreadA threadA = new ThreadA(tool);
            threadA.setName("A");
            ThreadB threadB = new ThreadB(tool);
            threadB.setName("B");
            threadA.start();
            threadB.start();
            Thread.sleep(2000);
            tool.show();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static class ThreadA extends Thread {

        private LockTool lockTool;

        public ThreadA(LockTool lockTool) {
            this.lockTool = lockTool;
        }

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

    public static class ThreadB extends Thread {

        private LockTool lockTool;

        public ThreadB(LockTool lockTool) {
            this.lockTool = lockTool;
        }

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

结果为：

A获取锁
B获取锁
是否有线程正在等待:true

isHeldByCurrentThread()

isHeldByCurrentThread()意思是查询当前线程是否保持锁定，下面我们来看看代码：

public class LockTool {

    public ReentrantLock lock = new ReentrantLock();

    public void test() {
        try {
            System.out.println("是否获取锁:" + lock.isHeldByCurrentThread());
            lock.lock();
            System.out.println("是否获取锁:" + lock.isHeldByCurrentThread());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        System.out.println(Thread.currentThread().getName() + "完成");
    }
}

public class lockmain {

    public static void main(String[] args) {
        try {
            LockTool tool = new LockTool();
            ThreadA threadA = new ThreadA(tool);
            threadA.setName("A");
            threadA.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static class ThreadA extends Thread {

        private LockTool lockTool;

        public ThreadA(LockTool lockTool) {
            this.lockTool = lockTool;
        }

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

结果为：

是否获取锁:false
是否获取锁:true
A完成

isLocked()

isLocked()方法是查询此锁是否有线程保持，下面我们来看看代码：

public class LockTool {

    public ReentrantLock lock = new ReentrantLock();

    public void test() {
        try {
            System.out.println("是否获取锁:" + lock.isLocked());
            lock.lock();
            System.out.println("是否获取锁:" + lock.isLocked());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        System.out.println(Thread.currentThread().getName() + "完成");
    }
}

public class lockmain {

    public static void main(String[] args) {
        try {
            LockTool tool = new LockTool();
            ThreadA threadA = new ThreadA(tool);
            threadA.setName("A");
            threadA.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static class ThreadA extends Thread {

        private LockTool lockTool;

        public ThreadA(LockTool lockTool) {
            this.lockTool = lockTool;
        }

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

结果为：

是否获取锁:false
是否获取锁:true
A完成

ReentrantReadWriteLock

在我们使用ReentrantLock的时候，每个锁之间是互斥的，这样的好处就是可以保证线程安全，但是在保证线程安全的同时，也会降低效率。Java给我们提供了ReentrantReadWriteLock类，可以让我们同时读取数据，这样可以提升代码的效率。

读写锁分为共享锁和排它锁，读操作就是共享锁，写操作就是排它锁。读和读之间不会互斥，读和写还有写和写之间是相互排斥的。

下面我看先来看看读和读之间是怎么使用的：

public class LockTool {

    public ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void test() {
        try {
            lock.readLock().lock();
            System.out.println(Thread.currentThread().getName() + "进入了锁：" + System.currentTimeMillis());
            Thread.sleep(10000);
            System.out.println(Thread.currentThread().getName() + "睡眠完毕");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
        System.out.println(Thread.currentThread().getName() + "完成");
    }
}

public class lockmain {

    public static void main(String[] args) {
        LockTool tool = new LockTool();
        for (int i = 0; i < 5; i++) {
            ThreadA threadA = new ThreadA(tool);
            threadA.start();
        }
    }

    public static class ThreadA extends Thread {

        private LockTool lockTool;

        public ThreadA(LockTool lockTool) {
            this.lockTool = lockTool;
        }

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

结果为：

Thread-0进入了锁：1566190832212
Thread-1进入了锁：1566190832212
Thread-2进入了锁：1566190832212
Thread-3进入了锁：1566190832212
Thread-4进入了锁：1566190832213

我们可以看见虽然都加了锁，但是5个线程全部都进入了锁，证明读和读之间是不互斥的。

然后我们看看读和写之间是否互斥：

public class LockTool {

    public ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void test1() {
        try {
            lock.readLock().lock();
            System.out.println(Thread.currentThread().getName() + "读 进入了锁：" + System.currentTimeMillis());
            Thread.sleep(10000);
            System.out.println(Thread.currentThread().getName() + "读 睡眠完毕");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
        System.out.println(Thread.currentThread().getName() + "完成");
    }

    public void test2() {
        try {
            lock.writeLock().lock();
            System.out.println(Thread.currentThread().getName() + "写 进入了锁：" + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println(Thread.currentThread().getName() + "写 睡眠完毕");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
        System.out.println(Thread.currentThread().getName() + "完成");
    }
}

public class lockmain {

    public static void main(String[] args) {
        LockTool tool = new LockTool();
        ThreadB threadB = new ThreadB(tool);
        threadB.start();
        for (int i = 0; i < 5; i++) {
            ThreadA threadA = new ThreadA(tool);
            threadA.start();
        }
    }

    public static class ThreadA extends Thread {

        private LockTool lockTool;

        public ThreadA(LockTool lockTool) {
            this.lockTool = lockTool;
        }

        @Override
        public void run() {
            lockTool.test1();
        }
    }

    public static class ThreadB extends Thread {

        private LockTool lockTool;

        public ThreadB(LockTool lockTool) {
            this.lockTool = lockTool;
        }

        @Override
        public void run() {
            lockTool.test2();
        }
    }
}

结果为：

Thread-0写 进入了锁：1566191059484
Thread-0写 睡眠完毕
Thread-0完成
Thread-1读 进入了锁：1566191064488
Thread-2读 进入了锁：1566191064488
Thread-3读 进入了锁：1566191064489
Thread-4读 进入了锁：1566191064489
Thread-5读 进入了锁：1566191064489

我们可以看到所有的读线程是在写线程完成过后才开始获取锁的，证明读和写是互斥的。

我们写下来看看写和写是是否也是互斥的，下面我们看看代码：

public class LockTool {

    public ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void test1() {
        try {
            lock.writeLock().lock();
            System.out.println(Thread.currentThread().getName() + "读 进入了锁：" + System.currentTimeMillis());
            Thread.sleep(10000);
            System.out.println(Thread.currentThread().getName() + "读 睡眠完毕");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
        System.out.println(Thread.currentThread().getName() + "完成");
    }
}

public class lockmain {

    public static void main(String[] args) {
        LockTool tool = new LockTool();
        for (int i = 0; i < 4; i++) {
            ThreadA threadA = new ThreadA(tool);
            threadA.start();
        }
    }

    public static class ThreadA extends Thread {

        private LockTool lockTool;

        public ThreadA(LockTool lockTool) {
            this.lockTool = lockTool;
        }

        @Override
        public void run() {
            lockTool.test1();
        }
    }
}

结果为：

Thread-0读 进入了锁：1566191219974
Thread-0读 睡眠完毕
Thread-0完成
Thread-1读 进入了锁：1566191229977
Thread-1读 睡眠完毕
Thread-1完成
Thread-2读 进入了锁：1566191239981
Thread-2读 睡眠完毕
Thread-2完成
Thread-3读 进入了锁：1566191249982
Thread-3读 睡眠完毕
Thread-3完成

我们可以看到每个线程都是完毕后，下一个线程才会获取锁并执行代码，这说明写和写之间同样是互斥的。

到这里有关Lock的基本使用就讲完了，上文中如果有错误的地方欢迎大家指出。

3Q

你可能感兴趣的:(简单聊聊 Java ReentrantLock)

  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 2021-08-26 影幽
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • 今天我破防了 sin信仰
    今天本来是大年初一，新年的第一天，应该是高高兴兴的一天，但是我怎么也高兴不起来。具体原因很简单，原本计划年后去县城找了一份会计的工作，被公公婆婆否定了，我心里立马就不舒服了，但是当时刚好肚子疼，我去了厕所，等我上完厕所，公公由于喝了酒还在那里和婆婆唠叨个没完。然后我就在心情极度压抑的情况下把午饭吃完的碗筷和锅给刷了。边刷碗筷和锅，边在那里难受，感觉自己在这个家里真的是过的憋屈死了，公婆不让我去上班
  • 关于提高复杂业务逻辑代码可读性的思考 编程经验分享 开发经验java数据库开发语言
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • GitHub上克隆项目 bigbig猩猩 github
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • Kafka 消息丢失如何处理？ 架构文摘JGWZ 学习
    今天给大家分享一个在面试中经常遇到的问题：Kafka消息丢失该如何处理？这个问题啊，看似简单，其实里面藏着很多“套路”。来，咱们先讲一个面试的“真实”案例。面试官问：“Kafka消息丢失如何处理？”小明一听，反问：“你是怎么发现消息丢失了？”面试官顿时一愣，沉默了片刻后，可能有点不耐烦，说道：“这个你不用管，反正现在发现消息丢失了，你就说如何处理。”小明一头雾水：“问题是都不知道怎么丢的，处理起来
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 数据仓库——维度表一致性 墨染丶eye 背诵数据仓库
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
  • C++菜鸟教程 - 从入门到精通 第二节 DreamByte c++
    一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
  • 想家，想念家乡的四季 三妹杨敏
    不知道，为什么，这次我回自己出生地—老家，反倒有了一种出差走亲戚的感觉。人啊，出来得久了，就生分了。就不再那么心贴着心脸对着脸了。需要时间，需要机缘，需要我们再重新把自己的思维重置一遍，你才能够转得回这个弯儿的。最好的转弯儿，不是说教，也不是余旧，都有些治标不治本。真正管用的东西，只有一样。也简单。一个字：吃。吃一顿家乡的饭，喝一口家乡的水，听一听那浓重得有些陌生的乡音，心就回来了。心回来，人才算
  • 2018-07-20 韻梅
    念亲爱的好感谢亲爱的每天照顾我们！因为有你我们心里踏实！念儿子的好儿子感谢你昨晚为我们煎手抓饼，让我们感到你满满的爱与幸福:你煎的与外边买的没有区别，也是脆脆的金黄黄的！我也不担心你的温饱问题，因为你能自己做简单的点心啊！儿子已经长大了，妈妈可要享福了咯！儿子加油！只要你敢想敢行动定能会成功的！
  • 南美洲的奇特艺术品【神秘档案馆·第三期】 清风小和尚
    本期回答问题：1.复活节岛石像是谁建造的？2.复活节岛石像的建造方法与目的？3.纳斯卡线条的设计意义？南美洲是南亚美利加洲的简称，位于西半球的南部，东濒大西洋，西临太平洋，北滨加勒比海，南隔德雷克海峡与南极洲相望。对南美洲最简单的定位方法是：美国南面。南美洲是地球上第四大的大洲，有着种类繁多的物种和丰富的地形。在这片广袤的土地上，有两样奇特的艺术品---复活节岛摩艾石像与纳斯卡线条。摩艾石像（Mo
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 摘选《靠谱》 海伦美少女
    作家池莉说：“靠谱，说起来简单，落下去复杂；听起来像感觉，做起来是原则。”靠谱的人，为人正直有原则，做事稳重重诺言。在他们眼里，人品比钱财重要，良心比利益可贵。和他们深交，不用防备，无需猜疑，相处最是舒心。魏晋名士嵇康和山涛，同为竹林七贤，两人私交甚笃。后来，山涛出仕为司马氏效力，嵇康则隐居山林。山涛几次举荐嵇康入朝为官，都被嵇康拒绝，最后甚至写下了绝交书。世人都认为两人恩断义绝，可两年后，嵇康遭
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 最超值的Mac——Mac mini 初心么么哒
    你知道最超值的Mac是什么吗？自2005年以来，Macmini一直是Apple台式机产品线中的主要产品。最初推出是为了让对Mac好奇的Mac进入Apple生态系统的一种简单方式，现在新的AppleSiliconMacmini可能是任何寻找新Mac的人的最有吸引力的购买。什么是AppleSiliconMacmini？M1Macmini是Apple最小的台式电脑，同时也是最快的台式电脑之一。最新型号由
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • 为什么你总是对下属不满意? ZhaoWu1050
    【ZhaoWu的听课笔记】大多数公司，都存在两种问题。我创业四年，更是体会深切。这两种问题就是：老板经常不满意下属的表现；下属总是不知道老板想要什么；虽然这两种问题普遍存在，其实解决方法并不复杂。这节课，我们再聊聊第一个问题：为什么老板经常不满意下属表现?其实，这背后也是一条管理常识。管理学家德鲁克先生早就说过：管理者的任务，不是去改变人。*来自《卓有成效的管理者》只是大多数老板和我一样，都是一边
  • Python实现简单的机器学习算法 master_chenchengg pythonpython办公效率python开发IT
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
  • 过了放弃的半生，很想偿偿坚持后的结果 乐安河
    这一阵子又迷茫了，找不到生活的目标，失去了坚持的意义，放弃太简单了，不想了，不看了，不写了，不做了，就行了。放弃的剎那，仿佛全身获得了解救，不再跟自己较劲，真轻松，真爽。短暂的惬意过后，是被抛弃的痛苦，是本该可以的不甘，是悔不当初的懊恼。我的前半生就是一次次的放弃过后的自我放逐。不愿努力，只好说平凡可贵，我们都是普通人，为什么非要整出仙人。不愿意轰轰烈烈，只想要现世安稳。只是，到最后发现，安稳变得
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • 分享100个最新免费的高匿HTTP代理IP mcj8089 代理IP代理服务器匿名代理免费代理IP最新代理IP
      推荐两个代理IP网站：   1. 全网代理IP：http://proxy.goubanjia.com/   2. 敲代码免费IP：http://ip.qiaodm.com/     120.198.243.130:80,中国/广东省 58.251.78.71:8088,中国/广东省 183.207.228.22:83,中国/
  • mysql高级特性之数据分区 annan211 java数据结构mongodb分区mysql
    mysql高级特性 1 以存储引擎的角度分析，分区表和物理表没有区别。是按照一定的规则将数据分别存储的逻辑设计。器底层是由多个物理字表组成。 2 分区的原理 分区表由多个相关的底层表实现，这些底层表也是由句柄对象表示，所以我们可以直接访问各个分区。存储引擎管理分区的各个底层 表和管理普通表一样(所有底层表都必须使用相同的存储引擎)，分区表的索引只是
  • JS采用正则表达式简单获取URL地址栏参数 chiangfai js地址栏参数获取
    GetUrlParam:function GetUrlParam(param){ var reg = new RegExp("(^|&)"+ param +"=([^&]*)(&|$)"); var r = window.location.search.substr(1).match(reg); if(r!=null
  • 怎样将数据表拷贝到powerdesigner (本地数据库表) Array_06 powerDesigner
    ================================================== 1、打开PowerDesigner12，在菜单中按照如下方式进行操作 file->Reverse Engineer->DataBase 点击后，弹出 New Physical Data Model 的对话框 2、在General选项卡中 Model name:模板名字，自
  • logbackのhelloworld 飞翔的马甲 日志logback
    一、概述 1.日志是啥？ 当我是个逗比的时候我是这么理解的：log.debug()代替了system.out.print(); 当我项目工作时，以为是一堆得.log文件。 这两天项目发布新版本，比较轻松，决定好好地研究下日志以及logback。 传送门1：日志的作用与方法： http://www.infoq.com/cn/articles/why-and-how-log 上面的作
  • 新浪微博爬虫模拟登陆 随意而生 新浪微博
    转载自：http://hi.baidu.com/erliang20088/item/251db4b040b8ce58ba0e1235     近来由于毕设需要，重新修改了新浪微博爬虫废了不少劲，希望下边的总结能够帮助后来的同学们。      现行版的模拟登陆与以前相比，最大的改动在于cookie获取时候的模拟url的请求
  • synchronized 香水浓 javathread
        Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍然
  • maven 简单实用教程 AdyZhang maven
    1. Maven介绍  1.1. 简介 java编写的用于构建系统的自动化工具。目前版本是2.0.9，注意maven2和maven1有很大区别，阅读第三方文档时需要区分版本。 1.2. Maven资源 见官方网站；The 5 minute test，官方简易入门文档；Getting Started Tutorial，官方入门文档；Build Coo
  • Android 通过 intent传值获得null aijuans android
    我在通过intent 获得传递兑现过的时候报错，空指针,我是getMap方法进行传值，代码如下 1 2 3 4 5 6 7 8 9 public void getMap(View view){            Intent i =
  • apache 做代理 报如下错误：The proxy server received an invalid response from an upstream baalwolf response
    网站配置是apache＋tomcat,tomcat没有报错，apache报错是： The proxy server received an invalid response from an upstream server. The proxy server could not handle the request GET /. Reason: Error reading fr
  • Tomcat6 内存和线程配置 BigBird2012 tomcat6
    1、修改启动时内存参数、并指定JVM时区 （在windows server 2008 下时间少了8个小时） 在Tomcat上运行j2ee项目代码时，经常会出现内存溢出的情况，解决办法是在系统参数中增加系统参数：  window下， 在catalina.bat最前面 set JAVA_OPTS=-XX:PermSize=64M -XX:MaxPermSize=128m -Xms5
  • Karam与TDD bijian1013 KaramTDD
    一.TDD         测试驱动开发（Test-Driven Development,TDD）是一种敏捷（AGILE）开发方法论，它把开发流程倒转了过来，在进行代码实现之前，首先保证编写测试用例，从而用测试来驱动开发（而不是把测试作为一项验证工具来使用）。         TDD的原则很简单： a.只有当某个
  • [Zookeeper学习笔记之七]Zookeeper源代码分析之Zookeeper.States bit1129 zookeeper
    public enum States { CONNECTING, //Zookeeper服务器不可用，客户端处于尝试链接状态 ASSOCIATING, //？？？ CONNECTED, //链接建立，可以与Zookeeper服务器正常通信 CONNECTEDREADONLY, //处于只读状态的链接状态，只读模式可以在
  • 【Scala十四】Scala核心八：闭包 bit1129 scala
    Free variable A free variable of an expression is a variable that’s used inside the expression but not defined inside the expression. For instance, in the function literal expression (x: Int) => (x
  • android发送json并解析返回json ronin47 android
    package com.http.test; import org.apache.http.HttpResponse; import org.apache.http.HttpStatus; import org.apache.http.client.HttpClient; import org.apache.http.client.methods.HttpGet; import
  • 一份IT实习生的总结 brotherlamp PHPphp资料php教程php培训php视频
    今天突然发现在不知不觉中自己已经实习了 3 个月了，现在可能不算是真正意义上的实习吧，因为现在自己才大三，在这边撸代码的同时还要考虑到学校的功课跟期末考试。让我震惊的是，我完全想不到在这 3 个月里我到底学到了什么，这是一件多么悲催的事情啊。同时我对我应该 get 到什么新技能也很迷茫。所以今晚还是总结下把，让自己在接下来的实习生活有更加明确的方向。最后感谢工作室给我们几个人这个机会让我们提前出来
  • 据说是2012年10月人人网校招的一道笔试题-给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。 将重物放到天平左侧，问在两边如何添加砝码 bylijinnan java
    public class ScalesBalance { /** * 题目： * 给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。 （假设N无限大，但一种重量的砝码只有一个） * 将重物放到天平左侧，问在两边如何添加砝码使两边平衡 * * 分析： * 三进制 * 我们约定括号表示里面的数是三进制，例如 47=(1202
  • dom4j最常用最简单的方法 chiangfai dom4j
    要使用dom4j读写XML文档,需要先下载dom4j包,dom4j官方网站在 http://www.dom4j.org/目前最新dom4j包下载地址:http://nchc.dl.sourceforge.net/sourceforge/dom4j/dom4j-1.6.1.zip 解开后有两个包,仅操作XML文档的话把dom4j-1.6.1.jar加入工程就可以了,如果需要使用XPath的话还需要
  • 简单HBase笔记 chenchao051 hbase
     一、Client-side write buffer 客户端缓存请求 描述：可以缓存客户端的请求，以此来减少RPC的次数，但是缓存只是被存在一个ArrayList中，所以多线程访问时不安全的。 可以使用getWriteBuffer()方法来取得客户端缓存中的数据。 默认关闭。 二、Scan的Caching 描述： next( )方法请求一行就要使用一次RPC,即使
  • mysqldump导出时出现when doing LOCK TABLES daizj mysqlmysqdump导数据
    　　执行　mysqldump -uxxx -pxxx -hxxx -Pxxxx database tablename > tablename.sql　 导出表时，会报 mysqldump: Got error: 1044: Access denied for user 'xxx'@'xxx' to database 'xxx' when doing LOCK TABLES 解决
  • CSS渲染原理 dcj3sjt126com Web
      从事Web前端开发的人都与CSS打交道很多，有的人也许不知道css是怎么去工作的，写出来的css浏览器是怎么样去解析的呢？当这个成为我们提高css水平的一个瓶颈时，是否应该多了解一下呢？          一、浏览器的发展与CSS           
  • 《阿甘正传》台词 dcj3sjt126com
    Part Ⅰ: 《阿甘正传》Forrest Gump经典中英文对白 Forrest: Hello! My names Forrest. Forrest Gump. You wanna Chocolate? I could eat about a million and a half othese. My momma always said life was like a box ochocol
  • Java处理JSON dyy_gusi json
    Json在数据传输中很好用，原因是JSON 比 XML 更小、更快，更易解析。 在Java程序中，如何使用处理JSON，现在有很多工具可以处理，比较流行常用的是google的gson和alibaba的fastjson，具体使用如下： 1、读取json然后处理 class ReadJSON { public static void main(String[] args)
  • win7下nginx和php的配置 geeksun nginx
    1.  安装包准备 nginx :  从nginx.org下载nginx-1.8.0.zip php： 从php.net下载php-5.6.10-Win32-VC11-x64.zip， php是免安装文件。 RunHiddenConsole: 用于隐藏命令行窗口   2. 配置 # java用8080端口做应用服务器，nginx反向代理到这个端口即可 p
  • 基于2.8版本redis配置文件中文解释 hongtoushizi redis
    转载自： http://wangwei007.blog.51cto.com/68019/1548167        在Redis中直接启动redis-server服务时, 采用的是默认的配置文件。采用redis-server   xxx.conf 这样的方式可以按照指定的配置文件来运行Redis服务。下面是Redis2.8.9的配置文
  • 第五章 常用Lua开发库3-模板渲染 jinnianshilongnian nginxlua
    动态web网页开发是Web开发中一个常见的场景，比如像京东商品详情页，其页面逻辑是非常复杂的，需要使用模板技术来实现。而Lua中也有许多模板引擎，如目前我在使用的lua-resty-template，可以渲染很复杂的页面，借助LuaJIT其性能也是可以接受的。   如果学习过JavaEE中的servlet和JSP的话，应该知道JSP模板最终会被翻译成Servlet来执行；而lua-r
  • JZSearch大数据搜索引擎 颠覆者 JavaScript
    系统简介： 大数据的特点有四个层面：第一，数据体量巨大。从TB级别，跃升到PB级别；第二，数据类型繁多。网络日志、视频、图片、地理位置信息等等。第三，价值密度低。以视频为例，连续不间断监控过程中，可能有用的数据仅仅有一两秒。第四，处理速度快。最后这一点也是和传统的数据挖掘技术有着本质的不同。业界将其归纳为4个“V”——Volume，Variety，Value，Velocity。大数据搜索引
  • 10招让你成为杰出的Java程序员 pda158 java编程框架
    如果你是一个热衷于技术的  Java 程序员， 那么下面的 10 个要点可以让你在众多 Java 开发人员中脱颖而出。 　　 1. 拥有扎实的基础和深刻理解 OO 原则 　　对于 Java 程序员，深刻理解 Object Oriented Programming（面向对象编程）这一概念是必须的。没有 OOPS 的坚实基础，就领会不了像 Java 这些面向对象编程语言
  • tomcat之oracle连接池配置 小网客 oracle
    tomcat版本7.0 配置oracle连接池方式： 修改tomcat的server.xml配置文件： <GlobalNamingResources> <Resource name="utermdatasource" auth="Container" type="javax.sql.DataSou
  • Oracle 分页算法汇总 vipbooks oraclesql算法.net
        这是我找到的一些关于Oracle分页的算法，大家那里还有没有其他好的算法没？我们大家一起分享一下！ -- Oracle 分页算法一 select * from ( select page.*,rownum rn from (select * from help) page -- 20 = (currentPag
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他