Lebens
Lebens

Java锁机制

Java多线程编程的入门篇，主要介绍volatile修饰词、Synchronized以及Lock及其子类

多线程编程主要存在的问题是数据的同步问题，下面我们讲讲几种保证数据同步的方法

volatile

要想了解volatile修饰词就必须先说说并发编程中的3个概念：

原子性

原子性指的是：多个操作要么全部执行不可中断，要么全部不执行。

可见性

可见性指的是：多线程操作同一个数据时，
其中一个线程操作完数据其他线程能立即看到数据的改变
（java中通过volatile来保证）。

有序性

有序性指的是：程序执行过程按照代码的顺序执行，
虽然编译器和处理器可能会对指令进行重排序，
但是保证执行的结果相同。

再来了解一下java的内存模型，就可以知道java怎么通过volatile来保证数据的可见性

java的内存模型

Java内存模型中规定，所有的数据都存储在主内存中，
线程对要操作的数据从主线程拷贝到自己的工作内存。
每个线程只能操作自己工作内存中的数据，不能直接操作主内存中的数据，
也不能访问其他线程的工作内存。
同时线程操作的数据可能存在缓存中，并不直接刷新到主内存中，

从上面可以知道，如果不保证数据的可见性，多个线程一起操作同一份数据时，并不能保证线程从主线程拷贝下来的数据是最新的，这样会让计算结果产生偏差。这个时候volatile就起作用了，被volatile修饰的变量，在被线程操作时数据的改变能直接刷新到主内存中，保证这个操作产生的新数据对其他线程是可见的，其他线程从主内存读取到是最新的数据。

同时volatile还有另外一个作用，被volatile修饰的变量将不能被编译器和处理器指令重排序。也就是volatile之后的语句不能提前到volatile之前，同时volatile之前的语句也不能排列到volatile之后。

示例：

class Singleton{
    private volatile static Singleton instance = null;
     
    private Singleton() {
         
    }
     
    public static Singleton getInstance() {
        if(instance==null) {
            synchronized (Singleton.class) {
                if(instance==null)
                    instance = new Singleton();
            }
        }
        return instance;
    }
}

参考文献Java并发编程：volatile关键字解析

Synchronized

Synchronized同步锁比较好理解，可以作用于代码块、成员方法以及静态方。但是要求锁住的部分，持有的是同一个锁对象，这时才能Synchronized起作用。

作用于代码块

某些情况下，我们可能在方法的一部分出现耗时操作，为了避免锁住整个方法可以用Synchronized同步代码块

public class SynchronizedTest {

    public static int sInt = 0;

    public static void main(String[] args) {

        new Thread(new MyRunnable(SynchronizedTest.class, false)).start();
        new Thread(new MyRunnable(SynchronizedTest.class, true)).start();
    }

    private static class MyRunnable implements Runnable {

        private final Object lock;

        boolean flag;

        public MyRunnable(Object lock, boolean flag) {
            this.lock = lock;
            this.flag = flag;
        }

        @Override
        public void run() {

            if (flag) {

                synchronized (lock) {

                    for (int i = 0; i < 1000; i++) {
                        sInt++;
                    }

                    System.out.println("calc finish");
                }
            } else {
                System.out.println("hello world");
            }
        }
    }
}

打印如下：

hello world 1525252712746
calc finish 1525252712747

可以看出同步访问

作用于成员方法

这个很好理解，我们需要锁住一整个方法，直接在方法上添加Synchronized即可

public class SynchronizedTest {

    public static int sInt = 0;

    public static void main(String[] args) {
        SynchronizedTest test = new SynchronizedTest();

        new Thread(new Runnable() {
            @Override
            public void run() {
                test.Test();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                test.Test();
            }
        }).start();
    }

    private synchronized void Test() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println("Test finish at " + System.currentTimeMillis());
        }
    }
}

打印如下：

Test finish at 1525253058767
Test finish at 1525253060770

可以看出两者的打印差了2秒以上。

这里需要特别说明一下，当Synchronized作用在成员方法上时其实是有锁对象的，持有的对象为当前的实例对象，这个和作用在静态方法上时有所区别，这个等下说。先看一下，不同实例时，成员方法上的锁是否生效。

public class SynchronizedTest {

    public static int sInt = 0;

    public static void main(String[] args) {
        SynchronizedTest testOne = new SynchronizedTest();
        SynchronizedTest testTwo = new SynchronizedTest();

        new Thread(new Runnable() {
            @Override
            public void run() {
                testOne.Test();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                testTwo.Test();
            }
        }).start();
    }

    private synchronized void Test() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println("Test finish at " + System.currentTimeMillis());
        }
    }
}

打印如下：

Test finish at 1525253495010
Test finish at 1525253495010

同时执行完毕，不同对象时锁依然存在，只是持有的锁对象不是同一个，所以才会同步打印。

作用于静态方法

public class SynchronizedTest {

    public static int sInt = 0;

    public static void main(String[] args) {
        SynchronizedTest testOne = new SynchronizedTest();
        SynchronizedTest testTwo = new SynchronizedTest();

        new Thread(new Runnable() {
            @Override
            public void run() {
                testOne.Test();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                testTwo.Test();
            }
        }).start();
    }

    public synchronized static void Test() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println("Test finish at " + System.currentTimeMillis());
        }
    }
}

打印如下：

Test finish at 1525253718091
Test finish at 1525253720095

这里和synchronized作用于成员方法时有区别，当synchronized作用于静态方法时，持有的锁对象为当前类的.class对象，所有不同的实例来操作都是同步的，因为.class对象是唯一的。

synchronized可重入性

先看一个示例

public class SynchronizedTest {

    private final Object mLock = new Object();

    public static void main(String[] args) {
        new SynchronizedTest().TestOne();
        System.out.println();
        new SynchronizedTest().TestFour();
    }


    private synchronized void TestOne() {
        System.out.println("Test One");
        TestTwo();
    }

    private synchronized void TestTwo() {
        System.out.println("Test Two");
        TestThree();
    }

    private synchronized void TestThree() {
        System.out.println("Test Three");
    }

    private void TestFour() {
        synchronized (mLock) {
            System.out.println("Test Four");
            TestFive();
        }
    }

    private void TestFive() {
        synchronized (mLock) {
            System.out.println("Test Five");
        }
    }
}

打印如下：

Test One
Test Two
Test Three

Test Four
Test Five

可以看出，程序并没有产生死锁，正常输入，这就是synchronized可重入性

在讲Lock前，先讲几个Object的方法

wait()、notify()以及notifyAll()

这几个方法是Object中的方法，所有每个锁对象都能调用

  1. wait()只有在同步代码块或者同步方法中才能调用，因为要保证当前线程持有锁对象。wait()的作用是让当前执行代码的线程进入等待状态，直到为唤起或者中断。
  2. notify()作用是将等待状态的线程唤起，让它等待获取锁对象。不同于notifyAll(),如果有多个线程需要唤起，notify()会随机挑选一个线程进行唤起，其他线程继续等待。notify()也需要获取到锁对象，同时被唤起的线程也不能立即被执行，因为需要等待notify()的线程执行完毕并释放锁。
  3. notifyAll()唤醒所有的等待线程，等到notifyAll()释放锁后同步执行

看一个notify的示例：

public class SynchronizedTest {

    public static void main(String[] args) {

        try {
            new Thread(new RunnableOne(Object.class)).start();
            Thread.sleep(1000);
            new Thread(new RunnableTwo(Object.class)).start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    private static class RunnableOne implements Runnable {

        private final Object mLock;

        RunnableOne(Object lock) {
            mLock = lock;
        }

        @Override
        public void run() {

            synchronized (mLock) {
                try {
                    System.out.println("wait start " + System.currentTimeMillis());
                    mLock.wait();
                    System.out.println("wait finish " + System.currentTimeMillis());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static class RunnableTwo implements Runnable {

        private final Object mLock;

        RunnableTwo(Object lock) {
            mLock = lock;
        }

        @Override
        public void run() {

            synchronized (mLock) {
                try {
                    Thread.sleep(2000);
                    mLock.notify();
                    System.out.println("notify thread " + System.currentTimeMillis());
                    Thread.sleep(2000);
                    System.out.println("notify finish " + System.currentTimeMillis());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

打印如下：

wait start 1525261601930
notify thread 1525261604937
notify finish 1525261606940
wait finish 1525261606941

可以清楚的看到notify结束后wait才执行，符合我们的预期

再来看一个notifyAll的示例，将上面的代码启动多个RunnableOne，notify()改成notifyAll(）

打印如下：

wait start 1525261838049
wait start 1525261838049
wait start 1525261838050
wait start 1525261838050
wait start 1525261838050
notify thread 1525261841060
notify finish 1525261843065
wait finish 1525261843065
wait finish 1525261843065
wait finish 1525261843065
wait finish 1525261843065
wait finish 1525261843066
死锁

死锁指的是某一线程一直持有锁对象不释放，其他线程无法获取锁对象的过程。产生死锁一般的原因都是多个锁对象一起使用，同时相互请求锁对象导致的。

看个示例：

public class SynchronizedTest {

    public static final Object LOCK_ONE = new Object();
    public static final Object LOCK_TWO = new Object();

    public static void main(String[] args) {
        try {
            new Thread(new RunnableOne()).start();
            Thread.sleep(1000);
            new Thread(new RunnableTwo()).start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static class RunnableOne implements Runnable {

        @Override
        public void run() {
            try {
                synchronized (LOCK_ONE) {
                    Thread.sleep(2000);
                    synchronized (LOCK_TWO) {
                        System.out.println(System.currentTimeMillis() + "");
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static class RunnableTwo implements Runnable {

        @Override
        public void run() {
            try {
                synchronized (LOCK_TWO) {
                    Thread.sleep(2000);
                    synchronized (LOCK_ONE) {
                        System.out.println(System.currentTimeMillis() + "");
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

直接死锁无打印，因为这里第一个线程启动的时候获取到了LOCK_ONE，接着睡眠，线程二启动，获取到了LOCK_TWO，睡眠。当第一个线程再次起来去获取LOCK_TWO时，等待LOCK_TWO被释放；当第二个线程再次起来去获取LOCK_ONE时，等待LOCK_ONE释放，相互等待对方释放锁，也即进入死锁状态。

Lock

Lock只是定义的一个接口，直接实现类是ReentrantLock，相对于synchronized锁，Lock可以在需要的情况下自我中断。下面来看一下ReentrantLock使用

public class LockTest {

    public static void main(String[] args) {
        try {
            ReentrantLock reentrantLock = new ReentrantLock();
            new Thread(new RunnableOne(reentrantLock)).start();
            Thread.sleep(1000);
            new Thread(new RunnableTwo(reentrantLock)).start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static class RunnableOne implements Runnable {

        final ReentrantLock mLock;

        public RunnableOne(ReentrantLock lock) {
            mLock = lock;
        }

        @Override
        public void run() {
            try {
                mLock.lock();
                System.out.println("RunnableOne get lock " + System.currentTimeMillis());
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                mLock.unlock();
            }
        }
    }

    private static class RunnableTwo implements Runnable {

        final ReentrantLock mLock;

        public RunnableTwo(ReentrantLock lock) {
            mLock = lock;
        }

        @Override
        public void run() {
            try {
                mLock.lock();
                System.out.println("RunnableTwo get lock " + System.currentTimeMillis());
            } finally {
                mLock.unlock();
            }
        }
    }
}

打印如下：

RunnableOne get lock 1525316728346
RunnableTwo get lock 1525316733350

线程2一直阻塞，等到线程1释放锁后才进行了打印，这和synchronized没区别

公平锁与非公平锁

当然ReentrantLock还有其他的特性，比如可以在实例化时指定是否为公平锁。公平锁和非公平锁的区别就是，公平锁所有线程按入队的顺序排队获取锁，非公平锁就是抢占机制，先入队并不一定获取到锁。

public class LockTest {

    public static void main(String[] args) {

        ReentrantLock reentrantLock = new ReentrantLock(false);
        Thread[] threads = new Thread[5];
        for (int i = 0; i < 5; i++) {
            threads[i] = new Thread(new RunnableOne(reentrantLock));
        }

        for (Thread thread : threads) {
            thread.start();
        }
    }

    private static class RunnableOne implements Runnable {

        final ReentrantLock mLock;

        RunnableOne(ReentrantLock lock) {
            mLock = lock;
        }

        @Override
        public void run() {

            try {
                mLock.lock();
                System.out.println(Thread.currentThread().getName() + " get lock ");
            } finally {
                mLock.unlock();
            }
        }
    }
}

非公平锁的情况下，打印如下：

Thread-0 get lock 
Thread-4 get lock 
Thread-1 get lock 
Thread-2 get lock 
Thread-3 get lock

提前启动的线程并没有先得到锁

再来看一下公平锁，只需要将ReentrantLock实例化时fair参数传入true即可，看一下打印：

Thread-0 get lock 
Thread-1 get lock 
Thread-2 get lock 
Thread-3 get lock 
Thread-4 get lock

符合先启动的线程先获取锁的预期。

Lock中断

相对于synchronized对线程中断的不处理，Lock还有一个方法lockInterruptibly(),可以让用户在必要的情况下自行中断对锁的请求，然后继续后续的操作。java的中断机制后续再写

来看一个例子

public class LockTest {

    public static void main(String[] args) {

        try {
            ReentrantLock reentrantLock = new ReentrantLock();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    reentrantLock.lock();
                }
            }).start();

            Thread.sleep(1000);

            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        reentrantLock.lockInterruptibly();
                    } catch (InterruptedException e) {
                        System.out.println("我被中断了");
                    }
                }
            });
            thread.start();
            Thread.sleep(1000);

            thread.interrupt();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

打印如下：

我被中断了

很明显的一个区别，当使用synchronized时，并不需要你去捕捉异常，因为线程会一直阻塞在等待锁的位置，就算你主动去thread.interrupt() synchronized并不会做任何处理。

lock.lockInterruptibly()使用时就需要你主动将此处的代码try/catch，因为在线程中断后，这里会捕捉异常并抛给你处理。这也给了你更灵活处理事物的能力。

Condition

synchronized中可以用锁对象的wait()、notify()以及notifyAll()实现等待，当然Lock也可以实现，不过子类实现相对应的Condition。

相对应的Condition里面的3个方法是await()、signal()、signalAll()。与wait()调用一样，await()之前也需要获取到锁对象，也就是Lock先要lock(),直接看例子

public class LockTest {

    public static void main(String[] args) {

        try {
            ReentrantLock reentrantLock = new ReentrantLock();
            Condition condition = reentrantLock.newCondition();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        reentrantLock.lock();
                        System.out.println("wait start");
                        condition.await();
                        System.out.println("wait finish");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        reentrantLock.unlock();
                    }
                }
            }).start();


            Thread.sleep(1000);

            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        reentrantLock.lock();
                        System.out.println("signal start");
                        condition.signal();
                        System.out.println("signal finish");
                    } finally {
                        reentrantLock.unlock();
                    }
                }
            });
            thread.start();
            Thread.sleep(1000);

            thread.interrupt();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

打印如下：

wait start
signal start
signal finish
wait finish

ReentrantLock的其他诸如isLocked()等方法这里就不再花篇幅说明，有兴趣的同学可以自己查看源码

总结

总结一下这篇文章的知识点：

  1. volatile修饰词：保证了操作的可见性，保证多线程操作时，数据从主内存拷贝的都是最新的
  2. Synchronized修饰词：可作用于代码块、成员方法已经静态方法上，配合锁对象的wait()、nofity()以及nofityAll()可以实现等待/通知模型。
    • 作用在代码块上时需要指定锁对象
    • 作用于成员方法上时锁对象为当前实例对象也就是xxx.this
    • 作用与静态方法上时锁对象为当前类的class对象也就是xxx.class
    • wait()、nofity()以及nofityAll()调用前需要获得锁对象。
  3. Lock：与Synchronized相比较用法就是需要用户手动上锁以及释放锁对象，同时多了一个lockInterruptibly()可以让用户手动中断等待线程，并捕获异常进行后续处理。配合Condition可以实现与Synchronized一样的等待/通知模型.
  4. 死锁：死锁指的是某一线程一直持有锁对象不释放，其他线程无法获取锁对象的过程。产生死锁一般的原因都是多个锁对象一起使用，同时相互请求锁对象导致的。

以上是个人能想到的关于锁的内容，并不保证写的完全对，如有问题可以留言给我，共同学习。

你可能感兴趣的:(Java锁机制)

  • 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()，那么我们在接口
  • 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分别代
  • 关于城市旅游的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：做与用户的交互行为文章目录前端学习路线
  • 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的运行
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 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
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 切换淘宝最新npm镜像源是 hai40587 npm前端node.js
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
  • 【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java开发语言
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式java
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
  • scala的option和some 矮蛋蛋 编程scala
    原文地址： http://blog.sina.com.cn/s/blog_68af3f090100qkt8.html 对于学习 Scala 的 Java™ 开发人员来说，对象是一个比较自然、简单的入口点。在 本系列 前几期文章中，我介绍了 Scala 中一些面向对象的编程方法，这些方法实际上与 Java 编程的区别不是很大。我还向您展示了 Scala 如何重新应用传统的面向对象概念，找到其缺点
  • NullPointerException Cb123456 androidBaseAdapter
        java.lang.NullPointerException: Attempt to invoke virtual method 'int android.view.View.getImportantForAccessibility()' on a null object reference     出现以上异常.然后就在baidu上
  • PHP使用文件和目录 天子之骄 php文件和目录读取和写入php验证文件php锁定文件
    PHP使用文件和目录 1.使用include()包含文件 (1)：使用include()从一个被包含文档返回一个值 (2)：在控制结构中使用include()   include_once()函数需要一个包含文件的路径，此外，第一次调用它的情况和include()一样，如果在脚本执行中再次对同一个文件调用，那么这个文件不会再次包含。   在php.ini文件中设置
  • SQL SELECT DISTINCT 语句 何必如此 sql
    SELECT DISTINCT 语句用于返回唯一不同的值。 SQL SELECT DISTINCT 语句 在表中，一个列可能会包含多个重复值，有时您也许希望仅仅列出不同（distinct）的值。 DISTINCT 关键词用于返回唯一不同的值。 SQL SELECT DISTINCT 语法 SELECT DISTINCT column_name,column_name F
  • java冒泡排序 3213213333332132 java冒泡排序
    package com.algorithm; /** * @Description 冒泡 * @author FuJianyong * 2015-1-22上午09:58:39 */ public class MaoPao { public static void main(String[] args) { int[] mao = {17,50,26,18,9,10
  • struts2.18 +json,struts2-json-plugin-2.1.8.1.jar配置及问题！ 7454103 DAOspringAjaxjsonqq
    struts2.18  出来有段时间了！ （貌似是 稳定版）   闲时研究下下！  貌似 sruts2 搭配 json 做 ajax 很吃香！   实践了下下！ 不当之处请绕过！ 呵呵   网上一大堆 struts2+json  不过大多的json 插件 都是 jsonplugin.34.jar   strut
  • struts2 数据标签说明 darkranger jspbeanstrutsservletScheme
    数据标签主要用于提供各种数据访问相关的功能，包括显示一个Action里的属性，以及生成国际化输出等功能 数据标签主要包括： action ：该标签用于在JSP页面中直接调用一个Action，通过指定executeResult参数，还可将该Action的处理结果包含到本页面来。 bean ：该标签用于创建一个javabean实例。如果指定了id属性，则可以将创建的javabean实例放入Sta
  • 链表.简单的链表节点构建 aijuans 编程技巧
    /*编程环境WIN-TC*/ #include "stdio.h" #include "conio.h" #define NODE(name, key_word, help) \  Node name[1]={{NULL, NULL, NULL, key_word, help}} typedef struct node {  &nbs
  • tomcat下jndi的三种配置方式 avords tomcat
    jndi(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。命名服务将名称和对象联系起来，使得我们可以用名称 访问对象。目录服务是一种命名服务，在这种服务里，对象不但有名称，还有属性。          tomcat配置
  • 关于敏捷的一些想法 houxinyou 敏捷
    从网上看到这样一句话：“敏捷开发的最重要目标就是：满足用户多变的需求，说白了就是最大程度的让客户满意。” 感觉表达的不太清楚。 感觉容易被人误解的地方主要在“用户多变的需求”上。 第一种多变，实际上就是没有从根本上了解了用户的需求。用户的需求实际是稳定的，只是比较多，也比较混乱，用户一般只能了解自己的那一小部分，所以没有用户能清楚的表达出整体需求。而由于各种条件的，用户表达自己那一部分时也有
  • 富养还是穷养，决定孩子的一生 bijian1013 教育人生
    是什么决定孩子未来物质能否丰盛？为什么说寒门很难出贵子，三代才能出贵族？真的是父母必须有钱，才能大概率保证孩子未来富有吗？-----作者：@李雪爱与自由 事实并非由物质决定，而是由心灵决定。一朋友富有而且修养气质很好，兄弟姐妹也都如此。她的童年时代，物质上大家都很贫乏，但妈妈总是保持生活中的美感，时不时给孩子们带回一些美好小玩意，从来不对孩子传递生活艰辛、金钱来之不易、要懂得珍惜
  • oracle 日期时间格式转化 征客丶 oracle
    oracle 系统时间有 SYSDATE 与 SYSTIMESTAMP； SYSDATE：不支持毫秒，取的是系统时间； SYSTIMESTAMP：支持毫秒，日期，时间是给时区转换的，秒和毫秒是取的系统的。 日期转字符窜： 一、不取毫秒： TO_CHAR(SYSDATE, 'YYYY-MM-DD HH24:MI:SS') 简要说明， YYYY 年 MM   月
  • 【Scala六】分析Spark源代码总结的Scala语法四 bit1129 scala
    1. apply语法   FileShuffleBlockManager中定义的类ShuffleFileGroup，定义：   private class ShuffleFileGroup(val shuffleId: Int, val fileId: Int, val files: Array[File]) { ... def apply(bucketId
  • Erlang中有意思的bug bookjovi erlang
      代码中常有一些很搞笑的bug，如下面的一行代码被调用两次（Erlang beam） commit f667e4a47b07b07ed035073b94d699ff5fe0ba9b Author: Jovi Zhang <[email protected]> Date: Fri Dec 2 16:19:22 2011 +0100 erts:
  • 移位打印10进制数转16进制-2008-08-18 ljy325 java基础
    /** * Description 移位打印10进制的16进制形式 * Creation Date 15-08-2008 9:00 * @author 卢俊宇 * @version 1.0 * */ public class PrintHex { // 备选字符 static final char di
  • 读《研磨设计模式》-代码笔记-组合模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; abstract class Component { public abstract void printStruct(Str
  • 利用cmd命令将.class文件打包成jar chenyu19891124 cmdjar
    cmd命令打jar是如下实现： 在运行里输入cmd，利用cmd命令进入到本地的工作盘符。(如我的是D盘下的文件有此路径 D:\workspace\prpall\WEB-INF\classes) 现在是想把D:\workspace\prpall\WEB-INF\classes路径下所有的文件打包成prpall.jar。然后继续如下操作： cd D: 回车 cd workspace/prpal
  • [原创]JWFD v0.96 工作流系统二次开发包 for Eclipse 简要说明 comsci eclipse设计模式算法工作swing
                           JWFD v0.96 工作流系统二次开发包 for Eclipse 简要说明     &nb
  • SecureCRT右键粘贴的设置 daizj secureCRT右键粘贴
    一般都习惯鼠标右键自动粘贴的功能，对于SecureCRT6.7.5 ，这个功能也已经是默认配置了。 老版本的SecureCRT其实也有这个功能，只是不是默认设置，很多人不知道罢了。 菜单： Options->Global Options ...->Terminal 右边有个Mouse的选项块。 Copy on Select Paste on Right/Middle
  • Linux 软链接和硬链接 dongwei_6688 linux
    1.Linux链接概念Linux链接分两种，一种被称为硬链接（Hard Link），另一种被称为符号链接（Symbolic Link）。默认情况下，ln命令产生硬链接。 【硬连接】硬连接指通过索引节点来进行连接。在Linux的文件系统中，保存在磁盘分区中的文件不管是什么类型都给它分配一个编号，称为索引节点号(Inode Index)。在Linux中，多个文件名指向同一索引节点是存在的。一般这种连
  • DIV底部自适应 dcj3sjt126com JavaScript
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
  • Centos6.5使用yum安装mysql——快速上手必备 dcj3sjt126com mysql
    第1步、yum安装mysql [root@stonex ~]#  yum -y install mysql-server 安装结果： Installed:     mysql-server.x86_64 0:5.1.73-3.el6_5                   &nb
  • 如何调试JDK源码 frank1234 jdk
    相信各位小伙伴们跟我一样，想通过JDK源码来学习Java，比如collections包，java.util.concurrent包。 可惜的是sun提供的jdk并不能查看运行中的局部变量，需要重新编译一下rt.jar。 下面是编译jdk的具体步骤：         1.把C:\java\jdk1.6.0_26\sr
  • Maximal Rectangle hcx2013 max
    Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing all ones and return its area.   public class Solution { public int maximalRectangle(char[][] matrix)
  • Spring MVC测试框架详解——服务端测试 jinnianshilongnian spring mvc test
    随着RESTful Web Service的流行，测试对外的Service是否满足期望也变的必要的。从Spring 3.2开始Spring了Spring Web测试框架，如果版本低于3.2，请使用spring-test-mvc项目（合并到spring3.2中了）。   Spring MVC测试框架提供了对服务器端和客户端（基于RestTemplate的客户端）提供了支持。 &nbs
  • Linux64位操作系统（CentOS6.6）上如何编译hadoop2.4.0 liyong0802 hadoop
    一、准备编译软件   1.在官网下载jdk1.7、maven3.2.1、ant1.9.4，解压设置好环境变量就可以用。     环境变量设置如下：   （1）执行vim /etc/profile （2）在文件尾部加入: export JAVA_HOME=/home/spark/jdk1.7 export MAVEN_HOME=/ho
  • StatusBar 字体白色 pangyulei status
    [[UIApplication sharedApplication] setStatusBarStyle:UIStatusBarStyleLightContent]; /*you'll also need to set UIViewControllerBasedStatusBarAppearance to NO in the plist file if you use this method
  • 如何分析Java虚拟机死锁 sesame javathreadoracle虚拟机jdbc
    英文资料： Thread Dump and Concurrency Locks   Thread dumps are very useful for diagnosing synchronization related problems such as deadlocks on object monitors. Ctrl-\ on Solaris/Linux or Ctrl-B
  • 位运算简介及实用技巧（一）：基础篇 tw_wangzhengquan 位运算
    http://www.matrix67.com/blog/archives/263    去年年底写的关于位运算的日志是这个Blog里少数大受欢迎的文章之一，很多人都希望我能不断完善那篇文章。后来我看到了不少其它的资料，学习到了更多关于位运算的知识，有了重新整理位运算技巧的想法。从今天起我就开始写这一系列位运算讲解文章，与其说是原来那篇文章的follow-up，不如说是一个r
  • jsearch的索引文件结构 yangshangchuan 搜索引擎jsearch全文检索信息检索word分词
    jsearch是一个高性能的全文检索工具包，基于倒排索引，基于java8，类似于lucene，但更轻量级。   jsearch的索引文件结构定义如下：     1、一个词的索引由=分割的三部分组成：        第一部分是词        第二部分是这个词在多少
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他