Minority
Minority

多线程高并发编程基础(代码示例+详解)

以下代码均通过使线程睡眠模拟实际业务场景来解释原理

Case1（synchronized 介绍）：

public class T {

    private int count = 10;
    private Object o = new Object();

    public void m() {
        synchronized (o){  //这里的加锁是对堆内存中的对象进行加锁，而不是对栈中的引用
            count--;
            System.out.println(Thread.currentThread().getName() + "count:" + count);
        }
    }

}

知识点：

  • synchronized锁定的是一个对象，而不是代码块
  • 对对象的加锁是对堆内存中的对象进行加锁，而不是对栈中的引用

上面的代码是new出来一个Object的对象，用来充当一把锁，也可以使用下面的方式对对象进行加锁：

public class T1 {

    private int count = 10;
    private Object o = new Object();

    public void m() {
        synchronized (this){  //这里的加锁是对堆内存中的对象进行加锁，而不是对栈中的引用
            count--;
            System.out.println(Thread.currentThread().getName() + "count:" + count);
        }
    }
}

知识点：

  • 上面的代码写成synchronized (this)，每次执行m函数时，就会锁定当前对象(new 出来的T1对象，而不是Object对象)

如果在函数开始的时候就要锁定，函数结束时才能释放的话，可以直接把锁加到函数上，如下：

public synchronized m(){
       count--;
       System.out.println(Thread.currentThread().getName() + "count:" + count);
    }

这种方式也不是锁定的代码，而是锁定的当前对象（函数所在的对象）。

Case2（对静态加锁）：

package com.gmail.fxding2019;

public class T2 {

    //当要锁定对象的是静态的时候
    private static  int count = 10;

    //对m方法加锁，实际上是锁定的com.gmail.fxding2019.T2.class。
    public synchronized static void m() {

            count--;
            System.out.println(Thread.currentThread().getName() + "count:" + count);
    }
}

知识点：

  • 对静态的加锁，锁定的不是对象，所以上面的代码并不等同于synchronized (this)，静态方法没有this
  • 对静态方法m加锁，实际上是锁定的com.gmail.fxding2019.T2.class

其实锁定的是T类型的class对象。等同于下面的代码：

public static void m(){
        synchronized (T2.class){
            count--;
            System.out.println(Thread.currentThread().getName() + "count:" + count);
        }
    }

Case3（解决线程重入问题）：

package com.gmail.fxding2019;

public class T3 implements Runnable {

    private int count = 10;

    public /*synchronized*/ void run(){
        count--;
        System.out.println(Thread.currentThread().getName() + "count:" + count);
    }

    public static void main(String[] args) {
        T3 t = new T3();
        for (int i = 0; i < 5; i++){
            new Thread(t, "Thread" + i + "：").start();
        }
    }
}


/*====================output========================
Thread0:count:8
Thread1:count:8
Thread4:count:7
Thread2:count:6
Thread3:count:5
*/

上面的代码是通过实现Runnable接口，重写run方法，new了一个对象t。然后创建了5个线程，其操作的count--都是堆中的同一个对象。上面的代码会出现线程的重入问题。

出现的原因就是：当Thread0运行完count--时（这时count=9），还没执行打印语句，Thread1就已经执行完了count--（这时count=8），然后Thread0和Thread1再执行打印语句。就得到了两个8。

解决的方法就是对run方法前面加一个synchronized关键字（对堆中的T对象进行加锁）。

Case4（线程启动的三种写法）：

package com.gmail.fxding2019;

public class T4{

    public synchronized void m1(){
        System.out.println(Thread.currentThread().getName() + ":m1 start ... ");
        try {
            Thread.sleep(10000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":m1 end ... ");
    }

    public void m2(){
        try {
            Thread.sleep(5000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + ":m2");
    }

    public static void main(String[] args) {
        T4 t = new T4();

        //lambda表达式写法
        new Thread(()->t.m1()).start();
        new Thread(()->t.m2()).start();


        /*映射的写法
        *new Thread(t::m1,"t1").start();
        new Thread(t::m2,"t2").start();
        * */


        /*原始匿名对象的写法
         new Thread(new Runnable() {
            @Override
            public void run() {
                t.m1();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t.m2();
            }
        }).start();
         */
    }
}

/*====================output========================
Thread-0:m1 start ... 
Thread-1:m2
Thread-0:m1 end ...
*/

上面的代码分别使用两个线程调用m1和m2方法，m1方法先启动，且m1是同步方法，m2方法后启动，m2方法是普通方法。

知识点：

  • 当执行m1时，是需要锁定当前的对象的，当执行m2时，是不需要锁定当前的对象的。那么，当执行m1的过程中，m2能否被执行？
    答案是可以的。只有加synchronized的方法才需要互斥等待。其他的方法不影响
  • 注意启动线程的三种写法：
    1. lambda表达式写法
    2. 映射的写法
    3. 原始匿名对象的写法

Case5（读脏数据）：

package com.gmail.fxding2019;

import java.util.concurrent.TimeUnit;

public class T5_Account {

    String name;
    double balance;  // 默认值为0.0

    public synchronized  void  set(String name, double balance){
        this.name = name;

        try {
            Thread.sleep(2000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        this.balance = balance;
    }

    public /*synchronized*/  double getBalance(String name){
        return this.balance;
    }

    public static void main(String[] args) {
        T5_Account a = new T5_Account();
        new Thread(()->a.set("zhangsan",100.0)).start();

        //TimeUnit是工具类，功能相当于sleep
        try {
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        //第一次读
        System.out.println(a.getBalance("zhangsan"));

        try {
            TimeUnit.SECONDS.sleep(2);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
         //第二次读
        System.out.println(a.getBalance("zhangsan"));

    }
}
/*====================output========================
0.0
100.0
*/

上面的代码对写的方法加锁，对读的方法不加锁，然后set改变Balance的值，通过睡眠的方式模拟两次读Balance，可以看到，结果是不一样的。

上面的代码只对set（写）设置了synchronized，没有对getBalance（读）设置，所以读不受同步的影响，这可就能能会导致读脏数据。脏读（dirtyRead）的定义：读到还没写成功的数据。解决的方法就是对读再进行加锁。

Case6（可重入锁）：

package com.gmail.fxding2019;

import java.util.concurrent.TimeUnit;

public class T6 {

    synchronized void m1(){
        System.out.println("m1 start");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //在同步方法中调用另一个同步方法
        m2();
    }


    synchronized void  m2(){
        try {
            TimeUnit.SECONDS.sleep(2);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        System.out.println("m2");
    }
}

知识点：

  • 一个同步的方法是可以调用另一个同步方法的。这是因为一个线程若已经有了某个对象的锁，再次申请时仍会得到该对象的锁（在堆中的操作就是在锁上面加了个数字，从1变成2，相当于锁定了2次）
  • 以上的例子说明了：synchronized获得的锁是可重入的（可重入：获得锁之后还可以再获得一遍）

重入锁的另一种情形：子类的同步方法调用父类的同步方法，其锁定的还是TT（子类）的this对象。new TT时会先创建父类的对象：

package com.gmail.fxding2019;

import java.util.concurrent.TimeUnit;

public class T7 {

    synchronized void m(){
        System.out.println("m start");

        try {
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        System.out.println("m end");
    }
}

class TT extends T7{
    synchronized void m(){
        System.out.println("child m start");
        super.m();
        System.out.println("child m end");
    }

    public static void main(String[] args) {
        new TT().m();
    }
}
/*====================output========================
child m start
m start
m end
child m end
*/

Case7（遇到异常释放锁）：

package com.gmail.fxding2019;

import java.util.concurrent.TimeUnit;

public class T8 {

    int count = 0;

    synchronized void  m(){
        System.out.println(Thread.currentThread().getName() + "start");

        while (true){
            count++;
            System.out.println(Thread.currentThread().getName() + "count = " + count);

            try {
                TimeUnit.SECONDS.sleep(1);
            }catch (InterruptedException e ){
                e.printStackTrace();
            }

            if(count == 5){
                int i = 1/0;  //此处会抛异常，锁会释放。要想不释放，就使用catch，使循环继续
            }
        }
    }

    public static void main(String[] args) {
        T8 t = new T8();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                t.m();
            }
        };

        new Thread(r, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(3);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        new Thread(r, "t2").start();  //如果t1不释放锁的话，t2永远执行不起来，因为while是死循环
    }
}

/*====================output========================
t1start
t1count = 1
t1count = 2
Exception in thread "t1" java.lang.ArithmeticException: / by zero
    at com.gmail.fxding2019.T8.m(T8.java:23)
    at com.gmail.fxding2019.T8$1.run(T8.java:33)
    at java.lang.Thread.run(Thread.java:745)
t2start
t2count = 3
t2count = 4
t2count = 5
*/

上面代码中，m方法使用while循环对count进行加1操作，当count = 5时，就执行1/0操作(会抛出by zero异常)。启动两个线程，先启动t1，再启动t2。如果出现异常锁不会被释放的话，那么t2永远得不到执行。而结果是t2得到了执行，所以t1出现异常后释放了锁。

知识点：

  • 程序在执行过程中，如果出现了异常，默认情况下锁是会被释放的(synchronized遇到异常锁会被释放)
  • 所以，在并发处理的过程中，有异常要多加小心，不然可能会造成不一致的情况：例如：在一个web app 处理的过程中，多个servlet线程共同访问同一个资源，这时候如果异常处理不合适，在某一个线程中出现了异常，而这个线程可能只执行可一半，这会导致其释放同步锁，其他的线程就会进入同步代码区。其他线程就有可能访问到上个线程处理了一半的数据。

Case8（volatile关键字）：

package com.gmail.fxding2019;

import java.util.concurrent.TimeUnit;

public class T9_volatile {

    /*volatile*/boolean running = true;

    void m(){
        System.out.println("m start");
        while (running){

        }

        System.out.println("m end");
    }

    public static void main(String[] args) {
        T9_volatile t = new T9_volatile();

        new Thread(t::m,"t1").start();

        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        t.running = false;  //主线程中把running改为false
    }
}

上面的代码就是通过设置running = true来是while出现死循环，即t1线程一直停不下来。虽然在主线程中设置了 t.running = false; 但是还是不起作用。如果在声明对running时加上volatile关键字，就可以使线程停下来。

产生这个现象的原因就是Java的JMM（java memory model）。可以这样理解：running保存在内存中，然后线程t1会把内存中的running copy到线程的缓存区中(每条线程还有自己的工作内存,可类比处理器的高速缓存类比，线程的工作内存中保存了该线程使用到的变量到主内存副本拷贝，线程对变量的所有操作（读取、赋值）都必须在工作内存中进行，而不能直接读写主内存中的变量。不同线程之间无法直接访问对方工作内存中的变量，线程间变量值的传递均需要在主内存来完成），所以while循环会一直执行。

这时候，主线程读取running的值到其线程缓冲区中，并把running的值改为false，由于running的值改变，所以主线程会把running=false再写回内存。但是t1线程并不会再从内存读数据了，所以t1会一直停不下来。

volatile关键字的作用就是：每当running在内存中的值发生改变时，会通知其他使用该变量的线程更新其缓存区。注意：是发生改变时才会从内存中读，而不是每一次都是从内存中读。volatile 并不能保证多个线程共同修改runing变量时所带来的不一致问题，也就是说volatile不能替代synchronized。volatile只能保证可见性，并不能保证原子性。

注意：多核CPU下，volatile也可以保证可见性，其他处理器通过嗅探总线上传播过来了数据监测自己缓存（每个CPU都有自己的缓存）的值是不是过期了，如果过期了，就会对应的缓存中的数据置为无效。而当处理器对这个数据进行修改时，会重新从内存中把数据读取到缓存中进行处理。

在这种情况下，不同的CPU之间就可以感知其他CPU对变量的修改，并重新从内存中加载更新后的值，因此可以解决可见性问题。

知识点总结：

  • volatile关键字，使一个变量在多个线程间可见：
    A、B线程都用到一个变量，java默认是A线程中保留一份copy，这样如果B线程修改了该变量，则A线程未必知道，使用volatile关键字，会让所有线程都读到该变量的修改值
  • 在上面的代码中，running是存在于堆内存的t对象中，当线程t1开始运行的时候，会把running值从内存中读到t1线程的工作区，在运行过程中直接使用这个copy，并不会每次都去读取堆内存，这样，当主线程修改running的值之后，t1线程感知不到，所以不会停止运行。使用volatile，当内存中的running改变时，将会强制所有线程都去堆内存读取running的值。
  • volatile不能替代synchronized。volatile只能保证可见性，并不能保证原子性

下面通过小示例来演示volatile不能替代synchronized。volatile只能保证可见性，并不能保证原子性：

package com.gmail.fxding2019;


import java.util.ArrayList;
import java.util.List;

// volatile 并不能保证多个线程共同修改runing变量时所带来的不一致问题，也就是说volatile不能替代synchronized。volatile只能保证可见性，并不能保证原子性
public class T10 {

    volatile  int count = 0;  //保证了线程之间的可见性

    /*synchronized*/  void m(){
        for (int i = 0; i<10000; i++){
            count++;
        }
    }



    public static void main(String[] args) {
        T10 t = new T10();

        List threads = new ArrayList();

        for (int i = 0; i< 10; i++){
            threads.add(new Thread(t::m,"Thread:" + i));
        }

        threads.forEach((o)->o.start());

        threads.forEach((o)->{
            try {
                //Thread类中的join方法的主要作用就是同步，它可以使得线程之间的并行执行变为串行执行
                o.join();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        });

        System.out.println(t.count);
    }
}
/*====================output========================
37517
*/

从结果中可以看出，所有线程对count的操作结果应该为100000，但是最后的结果才为37517。这就说明了volatile 并不能保证多个线程共同修改runing变量时所带来的不一致问题。如果对m方法加上synchronized*关键字则可以解决这个问题。

Case9（原子类AtomXX）：

package com.gmail.fxding2019;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class T11_AtomXX {

    //AtomicInteger是原子性的Integer类，用来进行简单的原子操作
    //凡是Atomic开头的，里面的方法都是原子性的，用来做简单的同步
    AtomicInteger count = new AtomicInteger(0);

    void  m(){
        for (int i = 0; i < 10000; i++){
            //incrementAndGet是原子操作，其是原子的方法，但并不是用synchronized实现的，而是用相当底层的方法，效率非常高
            //用来替代count++
            count.incrementAndGet();
        }
    }

    public static void main(String[] args) {
        T11_AtomXX t = new T11_AtomXX();

        List threads = new ArrayList();

        for (int i = 0; i< 10; i++){
            threads.add(new Thread(t::m,"Thread:" + i));
        }

        threads.forEach((o)->o.start());

        threads.forEach((o)->{
            try {
                o.join();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        });

        System.out.println(t.count);
    }
}
/*====================output========================
100000
*/

凡是Atomic开头的，里面的方法都是原子性的，用来做简单的同步，AtomicInteger是原子性的Integer类，用来进行简单的原子操作，上面的代码中，就是使用了AtomicInteger的incrementAndGet同步方法来代替count++。因为count++是原子性的，所以结果是100000，可以得到正确的结果。

知识点：

  • incrementAndGet是原子操作，其是原子的方法，但并不是用synchronized实现的，而是用相当底层的方法，效率非常高
  • 注意：Atomic的多个方法同时使用就不再具备原子性啦，比如：
if (count.get() < 1000){
              count.incrementAndGet();
        }

count.get()和count.incrementAndGet();都是原子性操作，但是在两条语句的中间还是有可能被其他线程打断

Case10（synchronized的简单优化 ）：

package com.gmail.fxding2019;

import java.util.concurrent.TimeUnit;

public class T12 {

    int count=0;


    //锁住了整个方法，锁的粒度比较粗
    synchronized void m1(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //业务逻辑中只有下面这句需要syn，这时不应给整个方法上锁
        count++;

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end=System.currentTimeMillis();

    }

    void m2(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        /**
         * 业务逻辑中只有下面这句需要syn，这时不应给整个方法上锁
         * 采用细粒度的锁，可以使线程争用时间变短，从而提高效率
         */

        //只锁住了count++，细粒度的锁
        synchronized (this){
            count++;
        }
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end=System.currentTimeMillis();
    }
}

synchronized简单的优化原则：同步代码块中的语句越少越好，比较m1和m2，都是对count++操作进行加锁同步。m1锁住了整个方法，m2只锁住了关键的操作count++(注意：synchronized锁住的是对象，这里提到的是指，当执行当关键语句时，才对整个对象加锁，提高并发度)。我们称对m1加的锁是粗粒度锁，对m2加的锁是细粒度锁。

Case11（锁的引用发生改变）：

package com.gmail.fxding2019;

import java.util.concurrent.TimeUnit;


public class T13 {

    Object o=new Object();

    void  m(){
        synchronized (o){
            while (true){
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }
        }
    }

    public static void main(String[] args) {
        T13 t=new T13();

        //启动第一个线程
        new Thread(t::m,"t1").start();

        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //创建第二个线程
        Thread t2=new Thread(t::m,"t2");
        t.o=new Object();   //锁发生改变，所以t2线程得以执行，如果注释掉这句话，线程2永远得不到执行机会
        t2.start();
    }
}

/*====================output========================
t1
t1
t1
t1
t2
t1
t2
t1
t2
t1
*/

上面代码中，t1锁住对象o后开始执行死循环，这时候把引用o执行的对象改变，然后执行t2再次锁定它。如果t1和t2锁定的是同一个对象的话，t2将得不到执行。从执行结果来看，t2锁定的和t1锁定的并不是同一个对象啦。

这个例子说明：锁定的并不是栈中的引用o，而是new出来的堆内存的对象，即锁的信息是记录在堆内存里面的。锁定某个对象o，如果o的属性发生改变，不影响锁的使用，但如果o变成另外一个对象，则锁定的对象发生改变，应该避免将锁定对象的引用变成另外的对象。

Case12（不要以字符串常量作为锁定对象）：

public class T14 {
    String s1="Hello";
    String s2="Hello";

    void m1(){
        synchronized (s1){

        }
    }

    void m2(){
        synchronized (s2){

        }
    }
}

上面代码锁定的是同一个对象。因为String类实现了常量池，hello存放在堆中的常量池中。常量池的概念见这篇文章。

在上面的例子中，m1和m2其实锁定的是同一个对象，这种情况还会发生比较诡异的现象，比如你用到了一个类库，在该类库中代码锁定了字符串"Hello"，但是你读不到源码，所以你在自己的代码中也锁定了"Hello"，这时候就有可能发生非常诡异的死锁阻塞，因为你的程序和你用到的类库不经意间使用了同一把锁。

Case13（wait && notify）：

面试题：
写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束

public class T15 {

    volatile List lists = new ArrayList();

    public void add(Object o){
        lists.add(o);
    }

    public int size(){

        return  lists.size();
    }

    public static void main(String[] args) {


        T15 t = new T15();

        new Thread(()->{

            for (int i=0; i<10; i++){
                t.add(new Object());
                System.out.println("add" + i);

                try {
                    TimeUnit.SECONDS.sleep(1);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }

        },"t1").start();

        new Thread(()->{
            while (true){
                if(t.size() == 5){
                    break;
                }
            }
            System.out.println("t2结束");
        },"t2").start();
    }
}


上面的实现中，如果对list不加volatile。那么list的size不可见。所以t2不会结束。


虽然上面的这个程序可以完成上述要求的功能，但是也存在两个问题：


    

  1. 通知的不精确，可能已经add8了，t2结束才打印出来（原因是没有进行同步）
    2. 

  2. 浪费cpu，t2一直用while进行检测
    3. 



给lists添加volatile之后，t2能够接到通知，但是t2线程的死循环很浪费cpu，如果不用死循环怎么做呢？可以尝试使用wait和notify解决这个问题，如下面的代码：


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class T16 {

    //添加volatile，使t2能够得到通知
    volatile List lists=new ArrayList();

    public void add(Object o){
        lists.add(o);
    }

    public int size(){
        return lists.size();
    }

    public static void main(String[] args) {
        T16 t = new T16();

        //声明一把锁
        final Object lock=new Object();

        new Thread(()->{

            //t2锁住lock，并进入wait状态。注意：进入wait前必须加锁
            //而wait后会释放lock锁，等待别的线程notify它。
            //这里必须先写t2的等待。再写t1
            synchronized (lock){
                System.out.println("t2启动");
                if (t.size()!=5){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("t2结束");
            }
        },"t2").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //t1对lock进行加锁。然后在t.size = 5时，再唤醒t2
        new Thread(()->{
            synchronized (lock){
                System.out.println("t1启动");
                for (int i = 0; i < 10; i++) {
                    t.add(new Object());
                    System.out.println("add "+i);


                    //注意：notify不用指定线程。也无法指定线程。对lock的notify cpu会自己找一个阻塞在lock上面的线程进行唤醒
                    if (t.size()==5){
                        lock.notify();
                    }

                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("t1结束");
            }
        },"t1").start();
    }
}
/*====================output========================
t2启动
t1启动
add 0
add 1
add 2
add 3
add 4
add 5
add 6
add 7
add 8
add 9
t1结束
t2结束
*/



上面的代码中，先使用wait让t2线程进行等待，然后启动t1不断向里面添加对象，等待size=5时，唤醒t2线程，打印t2结束。




注意：


    

  • wait后会释放lock锁，等待别的线程notify它
    • 

  • 上面的代码必须先写t2的等待，再写t1
    • 

  •  notify不用指定线程。也无法指定线程。对lock的notify cpu会自己找一个阻塞在lock上面的线程进行唤醒
    • 





然后上面这个程序还是存在一些问题：这个程序在t1唤醒t2时，t2并不会打印。而是等到t1运行退出时，t2才会打印。因为t2运行需要对lock进行加锁，而这把锁t1没运行完之前是不会释放的。所以上面的打印结果才出现t1结束后t2得到了打印。下面代码可以解决这个问题：


package com.gmail.fxding2019;

import java.util.ArrayList;
import java.util.List;

public class T17 {

    //保持list的size可见性
    volatile List lists = new ArrayList();

    public void add(Object o){
        lists.add(o);
    }

    public int size(){
        return lists.size();
    }

    public static void main(String[] args) {

        T17 t = new T17();

        //声明一把锁
        final  Object lock = new Object();

        new Thread(()->{

            System.out.println("t2启动");
            synchronized (lock){
                if (t.size() != 5){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                System.out.println("t2结束");

                //注意：必须在退出该锁之前唤醒其他阻塞在该锁上的线程
                //t2打印完，释放lock，唤醒t1继续运行
                lock.notify();
            }

        },"t2").start();


        new Thread(()->{

            synchronized (lock){

                System.out.println("t1启动");
                for (int i = 0; i<10; i++){
                    t.add(new Object());

                    System.out.println("add" + i);
                    if(t.size() == 5){
                        //通知t2
                        lock.notify();

                        try {
                            //阻塞t1，释放lock，等待t2拿到lock后打印
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                    }

                }
            }

        },"t1").start();
    }
}
/*====================output========================
t2启动
t1启动
add0
add1
add2
add3
add4
t2结束
add5
add6
add7
add8
add9
*/





上面的程序逻辑为：


    

  • t2先执行，遇到size!=5时调用wait等待，并释放对象的锁
    • 

  • t1拿到锁后再执行，不断向数组中添加，等到size=5时，使用notify唤醒t2，并且自己调用wait进行阻塞，释放对象锁(注意：一定要先唤醒t1后再进行自我阻塞)
    • 

  • 由于只有t2阻塞在该信号量上，所以notify会唤醒t2，进行打印。打印结束后，使用notify再唤醒t1
    • 

  • t1得到锁之后，继续执行，直到结束
    • 





Case14（CountDownLatch——门闩）：


package com.gmail.fxding2019;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;


public class T18_interviewFinal {
    //添加volatile，使t2能够得到通知
    volatile List lists=new ArrayList();

    public void add(Object o){
        lists.add(o);
    }

    public int size(){
        return lists.size();
    }

    public static void main(String[] args) {

        T18_interviewFinal c=new T18_interviewFinal();

        //CountDownLatch就是门闩，当CountDownLatch为0时，门闩就开啦
        CountDownLatch latch=new CountDownLatch(1);

        new Thread(()->{
            System.out.println("t2启动");
            if (c.size()!=5){
                try {

                    //等着开门
                    //门闩的等待是不需要锁定任何对象的
                    latch.await();

                    //也可以指定等待时间
                    //latch.await(5000,TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("t2结束");

        },"t2").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(()->{
            System.out.println("t1启动");
            for (int i = 0; i < 10; i++) {
                c.add(new Object());
                System.out.println("add "+i);

                if (c.size()==5){
                    //打开门闩，让t2得以执行
                    //只要调用一次CountDownLatch，其值就会减一
                    latch.countDown();
                }

                //门闩打开之后，t1是可以向下正常运行的

                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("t1结束");

        },"t1").start();
    }
}



使用Latch(门闩)替代wait notify来进行通知，好处是通信方式简单，同时也可以指定等待时间，使用await和countdown方法替代wait和notify，CountDownLatch不涉及锁定，当count的值为零是当前线程继续运行。当不涉及同步，只是涉及线程通信的时候，用synchronized+wait/notify就显得太重了的时候，时应该考虑CountDownLacth/cyclicbarrier/semaphore。




知识点：


    

  •  CountDownLatch latch=new CountDownLatch(1);CountDownLatch就是门闩，当CountDownLatch为0时，门闩就开啦，可以设置其初始值。
    • 

  • 门闩的等待是不需要锁定任何对象的，只要调用一次CountDownLatch，其值就会减一
    • 







 参考：马士兵老师java多线程高并发编程
























你可能感兴趣的:(多线程高并发编程基础(代码示例+详解))






    

  • Python中os.environ基本介绍及使用方法
鹤冲天Pro
#Pythonpython服务器开发语言

    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
    

    • 

  • 四章-32-点要素的聚合
彩云飘过

    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    

    • 

  • Python爬虫解析工具之xpath使用详解
eqa11
python爬虫开发语言

    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
    

    • 

  • 网络编程基础
记得开心一点啊
网络

    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
    

    • 

  • [Python] 数据结构 详解及代码
AIAdvocate
算法python数据结构链表

    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
    

    • 

  • 详解：如何设计出健壮的秒杀系统？
夜空_2cd3

    作者：Yrion博客园：cnblogs.com/wyq178/p/11261711.html前言：秒杀系统相信很多人见过，比如京东或者淘宝的秒杀，小米手机的秒杀。那么秒杀系统的后台是如何实现的呢？我们如何设计一个秒杀系统呢？对于秒杀系统应该考虑哪些问题？如何设计出健壮的秒杀系统？本期我们就来探讨一下这个问题：image目录一：****秒杀系统应该考虑的问题二：****秒杀系统的设计和技术方案三：*
    

    • 

  • 如何自学软件编程？零基础自学编程入门指南
_pangzi

    前言零基础自学编程的动力是什么?在开启学习编程之路的时候必须搞清楚自己为什么要学编程?是因为工资高?还是对编程有浓厚的兴趣？还有自己有一定的编程基础想要继续提升自己？其实对于这个问题需要具体分析，如果是单纯看到程序员工资高，而自己本身并没有什么兴趣，那我不建议自学，可以选择参加培训或者不要进入编程领域不然自己学不会没有获得高薪，反而浪费了大把的时间，如果方法不对，反而会打击自信心。下面小编针对学习
    

    • 

  • MyBatis 详解
阿贾克斯的黎明
javamybatis

    目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
    

    • 

  • 【Python】已解决：ModuleNotFoundError: No module named ‘PIL’
屿小夏
python开发语言

    文章目录一、分析问题背景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：ModuleNotFoundError:Nomodulenamed‘PIL’一、分析问题背景当你在Python环境中尝试导入PIL（PythonImagingLibrary）模块时，可能会遇到“ModuleNotFoundError:Nomodulenamed‘PIL’”的错误。这通常发生在尝试使用PIL
    

    • 

  • 【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
    

    • 

  • vue render 函数详解 (配参数详解)
你的眼睛會笑
vue2vue.jsjavascript前端

    vuerender函数详解(配参数详解)在Vue3中，`render`函数被用来代替Vue2中的模板语法。它接收一个h函数（或者是`createElement`函数的别名），并且返回一个虚拟DOM。render函数的语法结构如下：render(h){returnh('div',{class:'container'},'Hello,World!')}在上面的示例中，我们使用h函数创建了一个div元素
    

    • 

  • Dockerfile命令详解之 FROM
清风怎不知意
容器化java前端javascript

    许多同学不知道Dockerfile应该如何写，不清楚Dockerfile中的指令分别有什么意义，能达到什么样的目的，接下来我将在容器化专栏中详细的为大家解释每一个指令的含义以及用法。专栏订阅传送门https://blog.csdn.net/qq_38220908/category_11989778.html指令不区分大小写。但是，按照惯例，它们应该是大写的，以便更容易地将它们与参数区分开来。(引用
    

    • 

  • Dockerfile（1） - FROM 指令详解
小菠萝测试笔记
dockerpythonjavacmd大数据

    FROM指明当前的镜像基于哪个镜像构建dockerfile必须以FROM开头，除了ARG命令可以在FROM前面FROM[--platform=][AS]FROM[--platform=][:][AS]FROM[--platform=][@][AS]小栗子FROMalpine:latest一个dockerfile可以有多个FROM可以有多个FROM来创建多个镜像，或区分构建阶段，将一个构建阶段作为另
    

    • 

  • 详解“c:/work/src/components/a/b.vue“‘ has no default export报错原因
hw_happy
开发语言前端vue.jsjavascript

    前情提要在一个vue文件中需要引入定义的b.vue文件，但是提示b文件没有默认导出，对于vue2文件来说有exportdefault，在中，所有定义的变量、函数和组件都会自动被视为默认导出的组件内容。因此，不需要显式地使用exportdefault来导出组件。但是在我引用这个文件的时候还是提示了这个错误，原来是我的项目使用了ts和vite\webpack，因为TypeScript和Vue的默认导出
    

    • 

  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
屿小夏
java开发语言

    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    

    • 

  • 【显示 后台运行 & 的命令】
晨春计
debuglinux服务器运维

    目录背景步骤详解示例背景当你在Linuxshell中使用&符号将一个命令放到后台运行时，你可以使用jobs命令来查看这些后台进程的状态。但是，jobs命令并不会直接显示进程的PID（进程ID）。它会显示一个作业列表，其中包括每个作业的状态和一个作业标识符（通常是百分号%后面跟着一个数字），但不会直接显示PID。获取后台进程的PID步骤：1、使用jobs命令查看后台作业。2、使用ps命令配合grep
    

    • 

  • k8s中Service暴露的种类以及用法
听说唐僧不吃肉
K8Skubernetes容器云原生

    一、说明在Kubernetes中，有几种不同的方式可以将服务（Service）暴露给外部流量。这些方式通过定义服务的spec.type字段来确定。二、详解1.ClusterIP定义：默认类型，服务只能在集群内部访问。作用：通过集群内部IP地址暴露服务。示例：spec:type:ClusterIPports:-port:80targetPo
    

    • 

  • 【Python基础】Python迭代器与生成器（两种强大工具）
姑苏老陈
Python编程入门python开发语言python迭代器与生成器

    本文收录于《Python编程入门》专栏，从零基础开始，分享一些Python编程基础知识，欢迎关注，谢谢！文章目录一、前言二、迭代器2.1创建迭代器2.2自定义迭代器2.3处理大型文件三、生成器四、生成器表达式五、实际应用案例5.1数据库查询5.2网络数据流处理六、总结一、前言在Python中，迭代器与生成器是两种非常强大的工具，它们可以帮助我们有效地处理大量数据，特别是在需要逐个访问元素的情况下。
    

    • 

  • 详解mybatis的一二级缓存以及缓存失效原因
仰望天花板
缓存数据库mybatisjavamysql

    数据库的大部分场景下是从磁盘读取，如果数据从内存进行读取，速度较比磁盘要快得多。但因为内存的容量有限，所以一般只会把使用和查询较多的数据缓存起来，以便快速反应，其他使用率不太多的继续存放在磁盘。mybatis分为一级缓存和二级缓存1.一级缓存一级缓存存放在SqlSqeeion上，默认开启1.1pojo@DatapublicclassRole{privateLongid;privateStringr
    

    • 

  • pythonpandas函数详解_Python pandas常用函数详解
Senvn

    本文研究的主要是pandas常用函数，具体介绍如下。1import语句importpandasaspdimportnumpyasnpimportmatplotlib.pyplotaspltimportdatetimeimportre2文件读取df=pd.read_csv(path='file.csv')参数：header=None用默认列名，0，1，2，3...names=['A','B','C'
    

    • 

  • HTTP 响应状态码详解
云博客-资源宝
笔记httpHTTP响应状态码详解

    HTTP状态码详解：HTTP状态码,是用以表示WEB服务器HTTP响应状态的3位数字代码小技巧：Ctrl+F快速查找Http状态码状态码含义100客户端应当继续发送请求。这个临时响应是用来通知客户端它的部分请求已经被服务器接收，且仍未被拒绝。客户端应当继续发送请求的剩余部分，或者如果请求已经完成，忽略这个响应。服务器必须在请求完成后向客户端发送一个最终响应。101服务器已经理解了客户端的请求，并将
    

    • 

  • Linux中GCC与GDB 常用命令详解
Dijkstra's Monk-ey
Linux与安全linuxgdbshell安全c语言

    GCC和GDB常用命令详解GCC常用的选项GDBLINUX下编程，少不了和GCC,GDB打交道，现在总结下常用命令，掌握这些足够用了。GCC常用的选项选项语义-o指定生成的输出文件-E仅执行编译预处理gcc的-E选项，可以让编译器在预处理后停止，并输出预处理结果。-S将C代码转换为汇编代码gcc的-S选项，表示在程序编译期间，在生成汇编代码后停止-wall显示警告信息-c生成目标文件（.o），仅执
    

    • 

  • 腾讯发表多模态综述，一文详解多模态大模型
存内计算开发者社区
多模态大模型人工智能chatgptAIGC量子计算AI-nativegptagi

    多模态大语言模型（MLLM）是近年来兴起的一个新的研究热点，它利用强大的大语言模型作为大脑来执行多模态任务。MLLM令人惊讶的新兴能力，如基于图像写故事和无OCR的数学推理，在传统方法中是罕见的，这表明了一条通往人工通用智能的潜在道路。在本文中，追踪多模态大模型最新热点，讨论多模态关键技术以及现有在情绪识别上的应用。腾讯AILab发表了一篇关于多模态大模型的最新综述《MM-LLMs:RecentA
    

    • 

  • C++深拷贝构造函数解决浅拷贝的堆区内存重复释放问题
程序猿练习生
c++c++

    1.简单介绍先简单介绍一下浅拷贝和深拷贝：浅拷贝->简单的赋值拷贝操作，默认的拷贝构造函数就是浅拷贝。深拷贝->在堆区重新申请空间，进行拷贝操作。2.问题展示下面用代码示例明了地展示默认拷贝构造函数浅拷贝带来地堆区内存重复释放问题：#includeusingnamespacestd;classPerson{public:intm_Age;int*m_Height;public:Person(){c
    

    • 

  • OSPF LSA5、LSA7 中 FA 工作原理详解
斐夷所非
network网络

    FA(ForwardingAddress)仅出现在LSA5或LSA7中，它是数据包访问外部网络时，在数据报文离开OSPF路由域时必须经过的设备地址。LSA5作用LSA5区别于LSA3/LSA4，LSA5仅负责通告OSPF路由域外其他协议的路由，如RIP、BGP等。当外部路由引入到OSPF后，靠LSA5将其泛洪到OSPF路由域。LSA5具有其他LSA所没有的泛洪范围，除了特殊类型区域(Stub及NS
    

    • 

  • ⭐算法入门⭐《归并排序》简单01 —— LeetCode 21. 合并两个有序链表
英雄哪里出来
《LeetCode算法全集》算法数据结构链表c++归并排序

    饭不食，水不饮，题必须刷C语言免费动漫教程，和我一起打卡！《光天化日学C语言》LeetCode太难？先看简单题！《C语言入门100例》数据结构难？不存在的！《数据结构入门》LeetCode太简单？算法学起来！《夜深人静写算法》文章目录一、题目1、题目描述2、基础框架3、原题链接二、解题报告1、思路分析2、时间复杂度3、代码详解三、本题小知识一、题目1、题目描述  将两个不降序链表合并为一个新的不降
    

    • 

  • 上传文件到钉盘流程详解
jspyth
开发场景案例分析开发语言java后端

    文章目录前言准备工作实现过程Maven依赖封装一个工具类获取文件上传信息unionId获取钉盘目录spaceId创建上传到钉盘前言  本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。准备工作1、在钉钉开发者后台创建一个钉钉企业内部应用；2、创建并保存好应用的appKey和appSecret，后面用于获取调用API的请求token；3、应用中配置好所需权限：企业存储文件上传
    

    • 

  • 【Python】已解决：TypeError: unsupported operand
屿小夏
pythonjavaandroid

    文章目录一、分析问题背景出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：TypeError:unsupportedoperand一、分析问题背景TypeError:unsupportedoperand是Python中常见的一类错误，通常在尝试对不兼容的数据类型进行操作时发生。比如，当你尝试对字符串和整数进行加法操作时，Python会抛出这一错误。这样的错误通常发
    

    • 

  • Linux中open函数详解
460833359
LinuxClinuxopen函数

    初级文件I/O函数（即不用缓存的I/O函数）：open（打开文件）相关函数read，write，fcntl，create，lseek，close，link，stat，umask，unlink，fopen头文件#include#include#include定义函数intopen(constchar*pathname,intflags);intopen(constchar*pathname,intf
    

    • 

  • 对于规范和实现，你会混淆吗？
yangshangchuan
HotSpot

    昨晚和朋友聊天，喝了点咖啡，由于我经常喝茶，很长时间没喝咖啡了，所以失眠了，于是起床读JVM规范，读完后在朋友圈发了一条信息：
JVM Run-Time Data Areas：The Java Virtual Machine defines various run-time data areas that are used during execution of a program. So
    

    • 

  • android 网络
百合不是茶
网络

    android的网络编程和java的一样没什么好分析的都是一些死的照着写就可以了,所以记录下来  方便查找   ,  服务器使用的是TomCat
 
服务器代码;  servlet的使用需要在xml中注册
package servlet;
import java.io.IOException;
import java.util.Arr
    

    • 

  • [读书笔记]读法拉第传
comsci
读书笔记

    
      1831年的时候,一年可以赚到1000英镑的人..应该很少的...
      要成为一个科学家,没有足够的资金支持,很多实验都无法完成
      但是当钱赚够了以后....就不能够一直在商业和市场中徘徊......
    

    • 

  • 随机数的产生
沐刃青蛟
随机数

    c++中阐述随机数的方法有两种：
 
一是产生假随机数（不管操作多少次，所产生的数都不会改变）
 
       这类随机数是使用了默认的种子值产生的，所以每次都是一样的。
 
//默认种子
for (int i = 0; i < 5; i++)
{
cout<<
    

    • 

  • PHP检测函数所在的文件名
IT独行者
PHP函数

    很简单的功能，用到PHP中的反射机制，具体使用的是ReflectionFunction类，可以获取指定函数所在PHP脚本中的具体位置。 创建引用脚本。
代码：
 
[php]  
view plain
copy
// Filename: functions.php   
<?php&nbs
    

    • 

  • 银行各系统功能简介
文强chu
金融

    银行各系统功能简介 　 业务系统 核心业务系统 业务功能包括：总账管理、卡系统管理、客户信息管理、额度控管、存款、贷款、资金业务、国际结算、支付结算、对外接口等 清分清算系统 以清算日期为准，将账务类交易、非账务类交易的手续费、代理费、网络服务费等相关费用，按费用类型计算应收、应付金额，经过清算人员确认后上送核心系统完成结算的过程 国际结算系
    

    • 

  • Python学习1(pip django 安装以及第一个project)
小桔子
pythondjangopip

        最近开始学习python,要安装个pip的工具。听说这个工具很强大，安装了它，在安装第三方工具的话so easy!然后也下载了，按照别人给的教程开始安装，奶奶的怎么也安装不上！
第一步：官方下载pip-1.5.6.tar.gz, https://pypi.python.org/pypi/pip easy!
第二部：解压这个压缩文件，会看到一个setup.p
    

    • 

  • php 数组
aichenglong
PHP排序数组循环多维数组

    1 php中的创建数组
$product = array('tires','oil','spark');//array()实际上是语言结构而不  是函数
2 如果需要创建一个升序的排列的数字保存在一个数组中，可以使用range()函数来自动创建数组
$numbers=range(1,10)//1 2 3 4 5 6 7 8 9 10
$numbers=range(1,10,
    

    • 

  • 安装python2.7
AILIKES
python

    安装python2.7
1、下载可从 http://www.python.org/进行下载#wget https://www.python.org/ftp/python/2.7.10/Python-2.7.10.tgz
2、复制解压
#mkdir -p /opt/usr/python
#cp  /opt/soft/Python-2
    

    • 

  • java异常的处理探讨
百合不是茶
JAVA异常

    //java异常 
/*
1，了解java 中的异常处理机制，有三种操作
a,声明异常 
b,抛出异常 
c,捕获异常
2，学会使用try-catch-finally来处理异常
3，学会如何声明异常和抛出异常
4，学会创建自己的异常
 
*/
 
//2，学会使用try-catch-finally来处理异常
  
    

    • 

  • getElementsByName实例
bijian1013
element

    实例1：
<!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/x
    

    • 

  • 探索JUnit4扩展：Runner
bijian1013
java单元测试JUnit

            参加敏捷培训时，教练提到Junit4的Runner和Rule，于是特上网查一下，发现很多都讲的太理论，或者是举的例子实在是太牵强。多搜索了几下，搜索到两篇我觉得写的非常好的文章。
        文章地址：http://www.blogjava.net/jiangshachina/archive/20
    

    • 

  • [MongoDB学习笔记二]MongoDB副本集
bit1129
mongodb

    1. 副本集的特性
  1)一台主服务器(Primary),多台从服务器(Secondary)
  2)Primary挂了之后，从服务器自动完成从它们之中选举一台服务器作为主服务器，继续工作，这就解决了单点故障，因此，在这种情况下，MongoDB集群能够继续工作
  3)挂了的主服务器恢复到集群中只能以Secondary服务器的角色加入进来
 
2
    

    • 

  • 【Spark八十一】Hive in the spark assembly
bit1129
assembly

    Spark SQL supports most commonly used features of HiveQL. However, different HiveQL statements are executed in different manners:
1. DDL statements (e.g. CREATE TABLE, DROP TABLE, etc.)
    

    • 

  • Nginx问题定位之监控进程异常退出
ronin47

    nginx在运行过程中是否稳定，是否有异常退出过？这里总结几项平时会用到的小技巧。
1. 在error.log中查看是否有signal项，如果有，看看signal是多少。
比如，这是一个异常退出的情况：
$grep signal error.log
2012/12/24 16:39:56 [alert] 13661#0: worker process 13666 exited on s
    

    • 

  • No grammar constraints (DTD or XML schema).....两种解决方法
byalias
xml

    方法一：常用方法   关闭XML验证
工具栏：windows => preferences => xml => xml files => validation => Indicate when no grammar is specified:选择Ignore即可。
方法二：（个人推荐）
添加 内容如下
<?xml version=
    

    • 

  • Netty源码学习-DefaultChannelPipeline
bylijinnan
netty

    package com.ljn.channel;
/**
* ChannelPipeline采用的是Intercepting Filter 模式
* 但由于用到两个双向链表和内部类，这个模式看起来不是那么明显，需要仔细查看调用过程才发现
*
* 下面对ChannelPipeline作一个模拟，只模拟关键代码：
*/
public class Pipeline {

    

    • 

  • MYSQL数据库常用备份及恢复语句
chicony
mysql

    
备份MySQL数据库的命令，可以加选不同的参数选项来实现不同格式的要求。
mysqldump -h主机 -u用户名 -p密码 数据库名 > 文件
备份MySQL数据库为带删除表的格式，能够让该备份覆盖已有数据库而不需要手动删除原有数据库。
mysqldump -–add-drop-table -uusername -ppassword databasename > ba
    

    • 

  • 小白谈谈云计算--基于Google三大论文
CrazyMizzz
Google云计算GFS

        之前在没有接触到云计算之前，只是对云计算有一点点模糊的概念，觉得这是一个很高大上的东西，似乎离我们大一的还很远。后来有机会上了一节云计算的普及课程吧，并且在之前的一周里拜读了谷歌三大论文。不敢说理解，至少囫囵吞枣啃下了一大堆看不明白的理论。现在就简单聊聊我对于云计算的了解。
    我先说说GFS
  &n
    

    • 

  • hadoop 平衡空间设置方法
daizj
hadoopbalancer

    在hdfs-site.xml中增加设置balance的带宽，默认只有1M：
<property>
  <name>dfs.balance.bandwidthPerSec</name>
    <value>10485760</value>
    <description&g
    

    • 

  • Eclipse程序员要掌握的常用快捷键
dcj3sjt126com
编程

      判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。 曾有人在豆瓣评
《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个
程序员图书列表，目的也就是通过读书，让程序员变懒。  程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得
    

    • 

  • Android学习之路
dcj3sjt126com
Android学习

    转自：http://blog.csdn.net/ryantang03/article/details/6901459
以前有J2EE基础，接触JAVA也有两三年的时间了，上手Android并不困难，思维上稍微转变一下就可以很快适应。以前做的都是WEB项目，现今体验移动终端项目，让我越来越觉得移动互联网应用是未来的主宰。
下面说说我学习Android的感受，我学Android首先是看MARS的视
    

    • 

  • java 遍历Map的四种方法
eksliang
javaHashMapjava 遍历Map的四种方法

    转载请出自出处：
http://eksliang.iteye.com/blog/2059996
package com.ickes;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
/**
* 遍历Map的四种方式 
    

    • 

  • 【精典】数据库相关相关
gengzg
数据库

    package C3P0;
import java.sql.Connection;
import java.sql.SQLException;
import java.beans.PropertyVetoException;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class DBPool{ 
    

    • 

  • 自动补全
huyana_town
自动补全

    <!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&quo
    

    • 

  • jquery在线预览PDF文件，打开PDF文件
天梯梦
jquery

    最主要的是使用到了一个jquery的插件jquery.media.js，使用这个插件就很容易实现了。
 
核心代码
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.
    

    • 

  • ViewPager刷新单个页面的方法
lovelease
androidviewpagertag刷新

      使用ViewPager做滑动切换图片的效果时，如果图片是从网络下载的，那么再子线程中下载完图片时我们会使用handler通知UI线程，然后UI线程就可以调用mViewPager.getAdapter().notifyDataSetChanged()进行页面的刷新，但是viewpager不同于listview，你会发现单纯的调用notifyDataSetChanged()并不能刷新页面
    

    • 

  • 利用按位取反（~）从复合枚举值里清除枚举值
草料场
enum

    以 C# 中的 System.Drawing.FontStyle 为例。
 
如果需要同时有多种效果，
如：“粗体”和“下划线”的效果，可以用按位或（|）
FontStyle style = FontStyle.Bold | FontStyle.Underline;
 
如果需要去除 style 里的某一种效果， 
    

    • 

  • Linux系统新手学习的11点建议
刘星宇
编程工作linux脚本

    　　随着Linux应用的扩展许多朋友开始接触Linux，根据学习Windwos的经验往往有一些茫然的感觉：不知从何处开始学起。这里介绍学习Linux的一些建议。
　　一、从基础开始：常常有些朋友在Linux论坛问一些问题，不过，其中大多数的问题都是很基础的。例如：为什么我使用一个命令的时候，系统告诉我找不到该目录，我要如何限制使用者的权限等问题，这些问题其实都不是很难的，只要了解了 Linu
    

    • 

  • hibernate dao层应用之HibernateDaoSupport二次封装
wangzhezichuan
DAOHibernate

    /**
* <p>方法描述:sql语句查询 返回List<Class> </p>
* <p>方法备注: Class 只能是自定义类 </p>
* @param calzz
* @param sql
* @return
* <p>创建人：王川</p>
* <p>创建时间：Jul
    

    •