Jevely
Jevely

简单聊聊 Java线程间通信

哈喽，大家好，我们都知道线程的重要性，其中线程间通信可以使得线程更加的灵活，所以我们这次来聊聊线程间是如何通信的。

等待/通知机制

等待/通知机制简单来说就是当一个线程在等待的时候，由其他地方通知它不用等待了，然后该线程就继续执行下面的代码。举一个生活中的例子，等待/通知机制就好比我们网购，我们在网上买了东西并付钱过后我们就进入了等待的状态，需要等待商家的发货，等待快递员的送货。当快递员送货完成后，他们会打电话通知我们，我们买的东西已经送到，然后我们就知道下去拿快递。这就是一个简单的等待/通知机制。

在Java中等待/通知机制我们可以用wait方法和notify/notifyAll方法来实现。下面我们先用一个简单的例子来看下他们是如何使用的：

public class TestTool {

    private final Object object = new Object();

    public void user() {
        synchronized (object) {
            try {
                System.out.println("用户已经购买了商品,开始等待");
                object.wait();
                System.out.println("用户拿到了商品");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void process() {
        synchronized (object) {
            try {
                System.out.println("商品开始运送");
                Thread.sleep(5000);
                object.notify();
                System.out.println("商品运送完成");
                Thread.sleep(1000);
                System.out.println("通知用户来拿");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

public class ConmuMain {

    public static void main(String[] args) {
        try {
            TestTool testTool = new TestTool();
            ThreadA threadA = new ThreadA(testTool);
            ThreadB threadB = new ThreadB(testTool);
            threadA.start();
            Thread.sleep(1000);
            threadB.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static class ThreadA extends Thread {

        private TestTool testTool;

        public ThreadA(TestTool testTool) {
            this.testTool = testTool;
        }

        @Override
        public void run() {
            super.run();
            testTool.user();
        }
    }

    public static class ThreadB extends Thread {

        private TestTool testTool;

        public ThreadB(TestTool testTool) {
            this.testTool = testTool;
        }

        @Override
        public void run() {
            super.run();
            testTool.process();
        }
    }
}

结果为：

用户已经购买了商品,开始等待
商品开始运送
商品运送完成
通知用户来拿
用户拿到了商品

我们根据结果来分析一下过程。

  • 线程A中先调用user方法，拿到锁后又继续调用了wait方法进入了等待。
  • 过了1秒，调用了线程B的process方法，我们可以看见user方法和process方法都是以object为对象监视器加了锁的，在调用wait方法后代码进去了process说明了线程A中已经释放了锁，所以线程B的方法才能正常运行，我们得出结论在调用wait方法后会立刻释放当前的锁。
  • 经过了5秒，线程B中调用了notify方法，但这个时候线程A并没有立马执行，而是继续执行线程B后面的方法。
  • 等线程B执行完成后线程A才开始执行wait下面的代码，我们可以发现在调用notify方法后线程B继续执行，而且这个时候还没有释放锁，等到线程B执行完成并销毁后，才释放锁，这个时候线程A获取锁，然后继续执行wait后面的代码。

这就是wait，notify的整个流程。

notify是随机通知一个等待的线程

我们发现在调用nofity过后会通知一个线程停止等待，那么这个通知的线程是有一定规律还是随机的呢，这个我们用代码来看一下：

public class TestTool {

    private final Object object = new Object();

    public void inWait() {
        synchronized (object) {
            try {
                System.out.println(Thread.currentThread().getName() + "进入等待状态");
                object.wait();
                System.out.println(Thread.currentThread().getName() + "解除等待状态");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void inNotify() {
        synchronized (object) {
            try {
                System.out.println("解除一个线程");
                object.notify();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

public class ConmuMain {

    public static void main(String[] args) {
        try {
            TestTool testTool = new TestTool();
            for (int i = 0; i < 5; i++) {
                ThreadA threadA = new ThreadA(testTool);
                threadA.start();
            }
            Thread.sleep(1000);
            for (int i = 0; i < 2; i++) {
                ThreadB threadB = new ThreadB(testTool);
                threadB.start();
                Thread.sleep(1000);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static class ThreadA extends Thread {

        private TestTool testTool;

        public ThreadA(TestTool testTool) {
            this.testTool = testTool;
        }

        @Override
        public void run() {
            super.run();
            testTool.inWait();
        }
    }

    public static class ThreadB extends Thread {

        private TestTool testTool;

        public ThreadB(TestTool testTool) {
            this.testTool = testTool;
        }

        @Override
        public void run() {
            super.run();
            testTool.inNotify();
        }
    }
}

结果为：

Thread-0进入等待状态
Thread-2进入等待状态
Thread-1进入等待状态
Thread-3进入等待状态
Thread-4进入等待状态
解除一个线程
Thread-0解除等待状态
解除一个线程
Thread-2解除等待状态

我们可以看到这次通知的是线程0和2，并且我在多次运行后，发现通知的线程也不一样，没有规律，所以notify是随机通知一个正在等待的线程。

notifyAll

notifyAll方法就是通知所有的等待线程，我们修改下上面的代码来看看：

    public void inNotify() {
        synchronized (object) {
            try {
                System.out.println("解除所有线程");
                object.notifyAll();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        try {
            TestTool testTool = new TestTool();
            for (int i = 0; i < 5; i++) {
                ThreadA threadA = new ThreadA(testTool);
                threadA.start();
            }
            Thread.sleep(1000);
            ThreadB threadB = new ThreadB(testTool);
            threadB.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

结果为：

Thread-0进入等待状态
Thread-1进入等待状态
Thread-2进入等待状态
Thread-3进入等待状态
Thread-4进入等待状态
解除所有线程
Thread-4解除等待状态
Thread-3解除等待状态
Thread-2解除等待状态
Thread-1解除等待状态
Thread-0解除等待状态

在调用notifyAll方法过后，所有等待线程都结束了等待。

wait(long timeout)

这个方式是在等待多少秒后，如果没有其他线程通知这个线程，那么这个线程就自己取消等待，下面我们来看个例子：

public class TestTool {

    private final Object object = new Object();

    public void inWait() {
        synchronized (object) {
            try {
                System.out.println(Thread.currentThread().getName() + "进入等待状态");
                object.wait(2000);
                System.out.println(Thread.currentThread().getName() + "解除等待状态");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ConmuMain {

    public static void main(String[] args) {
        try {
            TestTool testTool = new TestTool();
            ThreadA threadA = new ThreadA(testTool);
            threadA.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static class ThreadA extends Thread {

        private TestTool testTool;

        public ThreadA(TestTool testTool) {
            this.testTool = testTool;
        }

        @Override
        public void run() {
            super.run();
            testTool.inWait();
        }
    }
}

结果为：

Thread-0进入等待状态
Thread-0解除等待状态

我们并没有用其他线程来通知该线程可以取消等待，但它还是自己取消了。

一对一生产消费模式

我们来举个例子，一个生产者，一个消费者，生产者每次只生产一个产品，等待消费者来消费，消费者每次只消费一个产品，下面我们来看看代码：

public class TestTool {

    private List list = new ArrayList<>();
    private final Object object = new Object();

    public void creatOne() {
        synchronized (object) {
            try {
                if (list.size() == 1) {
                    object.wait();
                }
                list.add(1);
                System.out.println("生产者生产一个产品:" + list.size());
                object.notify();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void consumeOne() {
        synchronized (object) {
            try {
                if (list.isEmpty()) {
                    object.wait();
                }
                list.remove(0);
                System.out.println("消费者消费一个产品:" + list.size());
                object.notify();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

public class ConmuMain {

    public static void main(String[] args) {
        try {
            TestTool testTool = new TestTool();
            ThreadA threadA = new ThreadA(testTool);
            ThreadB threadB = new ThreadB(testTool);
            threadA.start();
            threadB.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static class ThreadA extends Thread {

        private TestTool testTool;

        public ThreadA(TestTool testTool) {
            this.testTool = testTool;
        }

        @Override
        public void run() {
            super.run();
            while (true) {
                testTool.creatOne();
            }
        }
    }

    public static class ThreadB extends Thread {

        private TestTool testTool;

        public ThreadB(TestTool testTool) {
            this.testTool = testTool;
        }

        @Override
        public void run() {
            super.run();
            while (true) {
                testTool.consumeOne();
            }
        }
    }
}

结果为：

消费者消费一个产品:0
生产者生产一个产品:1
消费者消费一个产品:0
生产者生产一个产品:1
消费者消费一个产品:0
生产者生产一个产品:1
消费者消费一个产品:0
生产者生产一个产品:1
消费者消费一个产品:0
生产者生产一个产品:1
消费者消费一个产品:0
生产者生产一个产品:1
消费者消费一个产品:0
生产者生产一个产品:1
消费者消费一个产品:0
生产者生产一个产品:1
消费者消费一个产品:0
生产者生产一个产品:1
......

我们可以看到其中生产者和消费者都是按照预先设定好的模式来运行的，生产者生产的产品最大就是1。

一个生产者多个消费者

上面的写法在一个生产者一个消费者的情况下没有任何问题，那么在一个生产者多个消费者的情况下是否可以呢，我们下面来看看代码：

public class TestTool {

    private List list = new ArrayList<>();
    private final Object object = new Object();

    public void creatOne() {
        synchronized (object) {
            try {
                if (list.size() == 1) {
                    object.wait();
                }
                list.add(1);
                System.out.println("生产者生产一个产品:" + list.size());
                object.notify();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void consumeOne() {
        synchronized (object) {
            try {
                if (list.isEmpty()) {
                    object.wait();
                    System.out.println(Thread.currentThread().getName() + "取消等待");
                }
                list.remove(0);
                System.out.println(Thread.currentThread().getName() + "消费一个产品:" + list.size());
                object.notify();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

public class ConmuMain {

    public static void main(String[] args) {
        try {
            TestTool testTool = new TestTool();
            ThreadA threadA = new ThreadA(testTool);
            ThreadB threadB1 = new ThreadB(testTool);
            ThreadB threadB2 = new ThreadB(testTool);
            ThreadB threadB3 = new ThreadB(testTool);
            ThreadB threadB4 = new ThreadB(testTool);
            ThreadB threadB5 = new ThreadB(testTool);
            threadA.start();
            threadB1.start();
            threadB2.start();
            threadB3.start();
            threadB4.start();
            threadB5.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static class ThreadA extends Thread {

        private TestTool testTool;

        public ThreadA(TestTool testTool) {
            this.testTool = testTool;
        }

        @Override
        public void run() {
            super.run();
            while (true) {
                testTool.creatOne();
            }
        }
    }

    public static class ThreadB extends Thread {

        private TestTool testTool;

        public ThreadB(TestTool testTool) {
            this.testTool = testTool;
        }

        @Override
        public void run() {
            super.run();
            while (true) {
                testTool.consumeOne();
            }
        }
    }
}

结果为：

生产者生产一个产品:1
Thread-2消费一个产品:0
生产者生产一个产品:1
Thread-1取消等待
Thread-1消费一个产品:0
Thread-2取消等待
java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
    at java.util.ArrayList.rangeCheck(ArrayList.java:653)
    at java.util.ArrayList.remove(ArrayList.java:492)
    at conmuDemo.TestTool.consumeOne(TestTool.java:33)
    at conmuDemo.ConmuMain$ThreadB.run(ConmuMain.java:54)

结果报错了，我们通过日志可以发现在线程1消费了一个产品后生产者并没有生产产品，线程2又开始消费产品，这就导致了报错。我们修改下代码：

public class TestTool {

    private List list = new ArrayList<>();
    private final Object object = new Object();

    public void creatOne() {
        synchronized (object) {
            try {
                while (list.size() == 1) {
                    object.wait();
                }
                list.add(1);
                System.out.println("生产者生产一个产品:" + list.size());
                object.notify();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void consumeOne() {
        synchronized (object) {
            try {
                while (list.isEmpty()) {
                    object.wait();
                    System.out.println(Thread.currentThread().getName() + "取消等待");
                }
                list.remove(0);
                System.out.println(Thread.currentThread().getName() + "消费一个产品:" + list.size());
                object.notify();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

我们将原来的if判断变成了while判断，这样在取消等待过后会再次判断一次list的size，避免了上面的错误，我们运行下，结果为：

生产者生产一个产品:1
Thread-2消费一个产品:0
生产者生产一个产品:1
Thread-3消费一个产品:0
Thread-1取消等待
生产者生产一个产品:1
Thread-2消费一个产品:0
Thread-1取消等待
Thread-3取消等待

我们发现这里并没有报错了，但是出现了假死情况，我们再次修改代码：

public class TestTool {

    private List list = new ArrayList<>();
    private final Object object = new Object();

    public void creatOne() {
        synchronized (object) {
            try {
                while (list.size() == 1) {
                    object.wait();
                }
                list.add(1);
                System.out.println("生产者生产一个产品:" + list.size());
                object.notifyAll();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void consumeOne() {
        synchronized (object) {
            try {
                while (list.isEmpty()) {
                    object.wait();
                    System.out.println(Thread.currentThread().getName() + "取消等待");
                }
                list.remove(0);
                System.out.println(Thread.currentThread().getName() + "消费一个产品:" + list.size());
                object.notifyAll();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

我们将notify方法修改为notifyAll方法，来看看运行结果：

生产者生产一个产品:1
Thread-3取消等待
Thread-3消费一个产品:0
Thread-1取消等待
生产者生产一个产品:1
Thread-2取消等待
Thread-2消费一个产品:0
Thread-5取消等待
Thread-4取消等待
生产者生产一个产品:1
Thread-1取消等待
Thread-1消费一个产品:0
Thread-3取消等待
生产者生产一个产品:1
Thread-4取消等待
Thread-4消费一个产品:0
Thread-5取消等待
Thread-2取消等待
生产者生产一个产品:1
Thread-3取消等待
Thread-3消费一个产品:0
Thread-1取消等待
生产者生产一个产品:1
Thread-2取消等待
Thread-2消费一个产品:0

当修改了notify方法过后程序就可以完美运行了。

join

当我们使用主线程启动一个子线程的时候，如果子线程中有大量的耗时操作，那么子线程会晚于主线程结束。我们如果想让主线程在子线程执行完成后再执行的话，就可以用到join方法。

下面我们用简单的代码来看下join是如何使用的：

public class TestTool {

    public void test() {
        try {
            System.out.println("test start");
            Thread.sleep(5000);
            System.out.println("test finish");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ConmuMain {

    public static void main(String[] args) {
        try {
            TestTool testTool = new TestTool();
            ThreadA threadA = new ThreadA(testTool);
            threadA.start();
            threadA.join();
            System.out.println("main finish");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static class ThreadA extends Thread {

        private TestTool testTool;

        public ThreadA(TestTool testTool) {
            this.testTool = testTool;
        }

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

结果为：

test start
test finish
main finish

在使用join过后主线程在子线程执行完成后才继续执行，join内部是使用wait方法来实现的。

join与interrupt

如果在线程中使用join方法，那么该线程在调用interrupt方法后会报错，下面我们来看看代码：

public class ConmuMain {

    public static void main(String[] args) {
        try {
            ThreadB threadB = new ThreadB();
            threadB.start();
            Thread.sleep(2000);
            threadB.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static class ThreadA extends Thread {

        @Override
        public void run() {
            try {
                while (true) {
                    System.out.println("while");
                    Thread.sleep(1000);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static class ThreadB extends Thread {

        @Override
        public void run() {
            try {
                ThreadA threadA = new ThreadA();
                threadA.start();
                threadA.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
                System.out.println("ThreadB exception");
            }
        }
    }
}

结果为：

while
while
java.lang.InterruptedException
    at java.lang.Object.wait(Native Method)
    at java.lang.Thread.join(Thread.java:1252)
    at java.lang.Thread.join(Thread.java:1326)
    at conmuDemo.ConmuMain$ThreadB.run(ConmuMain.java:38)
ThreadB exception

我们在调用interrupt方法后，线程B出现了报错，这里我们进入join源码看看：

    public final void join() throws InterruptedException

我们发现造成报错的原因是因为join方法抛出了InterruptedException。

join(long millis)

join(long millis)方法是在限定时间内，如果线程还是堵塞状态，就取消堵塞，执行后面的代码，我们来看个例子：

public class TestTool {

    public void test() {
        try {
            System.out.println("test start");
            Thread.sleep(5000);
            System.out.println("test finish");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ConmuMain {

    public static void main(String[] args) {
        try {
            TestTool testTool = new TestTool();
            ThreadA threadA = new ThreadA(testTool);
            threadA.start();
            threadA.join(2000);
            System.out.println("main finish");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static class ThreadA extends Thread {

        private TestTool testTool;

        public ThreadA(TestTool testTool) {
            this.testTool = testTool;
        }

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

结果为：

test start
main finish
test finish

我们看到主线程先与子线程执行完。

线程间的通信基本上就讲完了，如果上文有错误的地方欢迎大家指出。

3Q

你可能感兴趣的:(简单聊聊 Java线程间通信)

  • 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分
  • 多线程编程之join()方法 周凡杨 javaJOIN多线程编程线程
    现实生活中，有些工作是需要团队中成员依次完成的，这就涉及到了一个顺序问题。现在有T1、T2、T3三个工人，如何保证T2在T1执行完后执行，T3在T2执行完后执行？问题分析：首先问题中有三个实体，T1、T2、T3， 因为是多线程编程，所以都要设计成线程类。关键是怎么保证线程能依次执行完呢？   Java实现过程如下： public class T1 implements Runnabl
  • java中switch的使用 bingyingao javaenumbreakcontinue
    java中的switch仅支持case条件仅支持int、enum两种类型。 用enum的时候，不能直接写下列形式。 switch (timeType) { case ProdtransTimeTypeEnum.DAILY: break; default: br
  • hive having count 不能去重 daizj hive去重having count计数
    hive在使用having count()是，不支持去重计数   hive (default)> select imei from t_test_phonenum where ds=20150701 group by imei having count(distinct phone_num)>1 limit 10;  FAILED: SemanticExcep
  • WebSphere对JSP的缓存 周凡杨 WAS JSP 缓存
          对于线网上的工程，更新JSP到WebSphere后，有时会出现修改的jsp没有起作用，特别是改变了某jsp的样式后，在页面中没看到效果，这主要就是由于websphere中缓存的缘故，这就要清除WebSphere中jsp缓存。要清除WebSphere中JSP的缓存，就要找到WAS安装后的根目录。        现服务
  • 设计模式总结 朱辉辉33 java设计模式
    1.工厂模式   1.1 工厂方法模式 (由一个工厂类管理构造方法)      1.1.1普通工厂模式(一个工厂类中只有一个方法)      1.1.2多工厂模式(一个工厂类中有多个方法)      1.1.3静态工厂模式(将工厂类中的方法变成静态方法) &n
  • 实例：供应商管理报表需求调研报告 老A不折腾 finereport报表系统报表软件信息化选型
    引言 随着企业集团的生产规模扩张，为支撑全球供应链管理，对于供应商的管理和采购过程的监控已经不局限于简单的交付以及价格的管理，目前采购及供应商管理各个环节的操作分别在不同的系统下进行，而各个数据源都独立存在，无法提供统一的数据支持；因此，为了实现对于数据分析以提供采购决策，建立报表体系成为必须。 业务目标 1、通过报表为采购决策提供数据分析与支撑 2、对供应商进行综合评估以及管理，合理管理和
  • mysql 林鹤霄
    转载源：http://blog.sina.com.cn/s/blog_4f925fc30100rx5l.html mysql -uroot -p ERROR 1045 (28000): Access denied for user 'root'@'localhost' (using password: YES)   [root@centos var]# service mysql
  • Linux下多线程堆栈查看工具(pstree、ps、pstack) aigo linux
    原文：http://blog.csdn.net/yfkiss/article/details/6729364   1. pstree pstree以树结构显示进程$ pstree -p work | grep adsshd(22669)---bash(22670)---ad_preprocess(4551)-+-{ad_preprocess}(4552)  &n
  • html input与textarea 值改变事件 alxw4616 JavaScript
    // 文本输入框(input) 文本域(textarea)值改变事件 // onpropertychange(IE) oninput(w3c) $('input,textarea').on('propertychange input', function(event) {      console.log($(this).val()) });  
  • String类的基本用法 百合不是茶 String
      字符串的用法;     // 根据字节数组创建字符串 byte[] by = { 'a', 'b', 'c', 'd' }; String newByteString = new String(by);         1,length()  获取字符串的长度     &nbs
  • JDK1.5 Semaphore实例 bijian1013 javathreadjava多线程Semaphore
    Semaphore类        一个计数信号量。从概念上讲，信号量维护了一个许可集合。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。 S
  • 使用GZip来压缩传输量 bijian1013 javaGZip
            启动GZip压缩要用到一个开源的Filter：PJL Compressing Filter。这个Filter自1.5.0开始该工程开始构建于JDK5.0，因此在JDK1.4环境下只能使用1.4.6。         PJL Compressi
  • 【Java范型三】Java范型详解之范型类型通配符 bit1129 java
        定义如下一个简单的范型类，   package com.tom.lang.generics; public class Generics<T> { private T value; public Generics(T value) { this.value = value; } }
  • 【Hadoop十二】HDFS常用命令 bit1129 hadoop
    1. 修改日志文件查看器   hdfs oev -i edits_0000000000000000081-0000000000000000089 -o edits.xml cat edits.xml   修改日志文件转储为xml格式的edits.xml文件，其中每条RECORD就是一个操作事务日志   2. fsimage查看HDFS中的块信息等 &nb
  • 怎样区别nginx中rewrite时break和last ronin47
    在使用nginx配置rewrite中经常会遇到有的地方用last并不能工作，换成break就可以，其中的原理是对于根目录的理解有所区别，按我的测试结果大致是这样的。 location /    {         proxy_pass http://test; 
  • java-21.中兴面试题 输入两个整数 n 和 m ，从数列 1 ， 2 ， 3.......n 中随意取几个数 , 使其和等于 m bylijinnan java
    import java.util.ArrayList; import java.util.List; import java.util.Stack; public class CombinationToSum { /* 第21 题 2010 年中兴面试题 编程求解： 输入两个整数 n 和 m ，从数列 1 ， 2 ， 3.......n 中随意取几个数 , 使其和等
  • eclipse svn 帐号密码修改问题 开窍的石头 eclipseSVNsvn帐号密码修改
    问题描述：      Eclipse的SVN插件Subclipse做得很好，在svn操作方面提供了很强大丰富的功能。但到目前为止，该插件对svn用户的概念极为淡薄，不但不能方便地切换用户，而且一旦用户的帐号、密码保存之后，就无法再变更了。 解决思路：      删除subclipse记录的帐号、密码信息，重新输入
  • [电子商务]传统商务活动与互联网的结合 comsci 电子商务
          某一个传统名牌产品，过去销售的地点就在某些特定的地区和阶层，现在进入互联网之后，用户的数量群突然扩大了无数倍，但是，这种产品潜在的劣势也被放大了无数倍，这种销售利润与经营风险同步放大的效应，在最近几年将会频繁出现。。。。        如何避免销售量和利润率增加的
  • java 解析 properties-使用 Properties-可以指定配置文件路径 cuityang javaproperties
    #mq xdr.mq.url=tcp://192.168.100.15:61618; import java.io.IOException; import java.util.Properties; public class Test { String conf = "log4j.properties"; private static final
  • Java核心问题集锦 darrenzhu java基础核心难点
    注意，这里的参考文章基本来自Effective Java和jdk源码 1)ConcurrentModificationException 当你用for each遍历一个list时，如果你在循环主体代码中修改list中的元素，将会得到这个Exception，解决的办法是： 1)用listIterator, 它支持在遍历的过程中修改元素， 2)不用listIterator, new一个
  • 1分钟学会Markdown语法 dcj3sjt126com markdown
    markdown 简明语法 基本符号 *,-,+ 3个符号效果都一样，这3个符号被称为 Markdown符号 空白行表示另起一个段落 `是表示inline代码，tab是用来标记 代码段，分别对应html的code，pre标签 换行 单一段落( <p>) 用一个空白行 连续两个空格 会变成一个 <br> 连续3个符号，然后是空行
  • Gson使用二（GsonBuilder） eksliang jsongsonGsonBuilder
    转载请出自出处：http://eksliang.iteye.com/blog/2175473 一.概述     GsonBuilder用来定制java跟json之间的转换格式   二.基本使用 实体测试类： 温馨提示：默认情况下@Expose注解是不起作用的,除非你用GsonBuilder创建Gson的时候调用了GsonBuilder.excludeField
  • 报ClassNotFoundException: Didn't find class "...Activity" on path: DexPathList gundumw100 android
    有一个工程，本来运行是正常的，我想把它移植到另一台PC上，结果报： java.lang.RuntimeException: Unable to instantiate activity ComponentInfo{com.mobovip.bgr/com.mobovip.bgr.MainActivity}: java.lang.ClassNotFoundException: Didn't f
  • JavaWeb之JSP指令 ihuning javaweb
      要点   JSP指令简介  page指令  include指令    JSP指令简介    JSP指令（directive）是为JSP引擎而设计的，它们并不直接产生任何可见输出，而只是告诉引擎如何处理JSP页面中的其余部分。 JSP指令的基本语法格式： <%@ 指令 属性名="
  • mac上编译FFmpeg跑ios 啸笑天 ffmpeg
    1、下载文件：https://github.com/libav/gas-preprocessor， 复制gas-preprocessor.pl到/usr/local/bin/下， 修改文件权限：chmod 777 /usr/local/bin/gas-preprocessor.pl 2、安装yasm-1.2.0 curl http://www.tortall.net/projects/yasm
  • sql mysql oracle中字符串连接 macroli oraclesqlmysqlSQL Server
    有的时候，我们有需要将由不同栏位获得的资料串连在一起。每一种资料库都有提供方法来达到这个目的： MySQL: CONCAT() Oracle: CONCAT(), || SQL Server: + CONCAT() 的语法如下： Mysql 中 CONCAT(字串1, 字串2, 字串3, ...): 将字串1、字串2、字串3，等字串连在一起。 请注意，Oracle的CON
  • Git fatal: unab SSL certificate problem: unable to get local issuer ce rtificate qiaolevip 学习永无止境每天进步一点点git纵观千象
    // 报错如下： $ git pull origin master fatal: unable to access 'https://git.xxx.com/': SSL certificate problem: unable to get local issuer ce rtificate   // 原因： 由于git最新版默认使用ssl安全验证，但是我们是使用的git未设
  • windows命令行设置wifi surfingll windowswifi笔记本wifi
    还没有讨厌无线wifi的无尽广告么，还在耐心等待它慢慢启动么 教你命令行设置 笔记本电脑wifi： 1、开启wifi命令 netsh wlan set hostednetwork mode=allow ssid=surf8 key=bb123456 netsh wlan start hostednetwork pause 其中pause是等待输入，可以去掉 2、
  • Linux（Ubuntu）下安装sysv-rc-conf wmlJava linuxubuntusysv-rc-conf
    安装：sudo apt-get install sysv-rc-conf 使用：sudo sysv-rc-conf 操作界面十分简洁，你可以用鼠标点击，也可以用键盘方向键定位，用空格键选择，用Ctrl+N翻下一页，用Ctrl+P翻上一页，用Q退出。     背景知识 sysv-rc-conf是一个强大的服务管理程序，群众的意见是sysv-rc-conf比chkconf
  • svn切换环境，重发布应用多了javaee标签前缀 zengshaotao javaee
    更换了开发环境，从杭州，改变到了上海。svn的地址肯定要切换的，切换之前需要将原svn自带的.svn文件信息删除，可手动删除，也可通过废弃原来的svn位置提示删除.svn时删除。   然后就是按照最新的svn地址和规范建立相关的目录信息，再将原来的纯代码信息上传到新的环境。然后再重新检出，这样每次修改后就可以看到哪些文件被修改过，这对于增量发布的规范特别有用。   检出
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他