zl_StepByStep
zl_StepByStep

Java高并发编程 （马士兵老师视频）笔记（一）同步器

本篇主要总结同步器的相关例子：包括synchronized、volatile、原子变量类（AtomicXxx）、CountDownLatch、ReentrantLock和ThreadLocal。还涉及到wait和notify/notifyAll。

回忆关于线程的几个基本知识点：

◆ 线程的概念（程序中不同的执行路径可以放到不同的CPU中同步运行）；

◆ 如何启动一个线程（继承Thread类 / 实现Runnable接口 / 实现Callable接口，，，调用start()方法）；

◆ 基本的线程同步方式  （synchronized——锁定的是一个对象、...）

对于synchronized的理解：

    由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类。

目录

1.对某个对象加锁

♣ 例1.1：new一个对象作为锁

♣ 例1.2：锁定自身对象

♣ 例1.3：synchronized用在静态方法上

♣ 例1.4：锁住线程的run方法

♣ 例1.5：同步方法与非同步方法是否可以同时调用？—— 可以

♣ 例1.6：对业务写方法加锁，对业务读方法不加锁，容易产生脏读问题。

♣ 例1.7：一个同步方法可以调用另外一个同步方法吗——可以

♣ 例1.8：在继承中，子类重写的同步方法可以调用父类的同步方法

♣ 例1.9：出现异常，默认情况下锁会被释放，

2.volatile关键字——使一个变量在多个线程中可见

♣ 例2.1 volatile的可见性

♣ 例2.2  volatile不具备原子性

♣ 例2.3  synchronized既保证可见性又保证了原子性

♣例2.4 实现一个容器，提供两个方法add、size，线程1添加10个元素到容器，线程2监控元素的的个数，当个数为5个时，线程2提示并结束。

  ♣♣ 2.4.1 给容器list添加volatile

  ♣♣ 2.4.2  使用wait()和notify()做到，wait释放锁，而notify不会释放锁

  ♣♣ 2.4.3 使用CountDownLatch（门闩）的await和countdown方法替代wait、notify方法来进行通知。

3.原子变量类（AtomXxx）

♣ 例3.1  原子性操作int类型——AtomicInteger

4.ReentrantLock-重入锁

♣ 例4.1 ReentrantLock可以用来代替synchronized

♣ 例4.2  ReentrantLock可以进行尝试锁定tryLock()

♣ 例4.3  ReentrantLock可调用lockInterruptibly方法，对线程的interrupt方法作出响应，在一个线程等待的过程中，可以被打断。

♣ 例4.4 ReentrantLock可以指定为共享锁

♣ 例4.5  写一个固定容量的同步容器，拥有put和get方法，以及getCount方法，能够支持2个生产者线程以及10个消费者线程的阻塞调用。

  ♣♣  4.5.1 使用wait和notify/notifyAll()来实现

  ♣♣  4.5.1 使用Lock和Condition来实现

5.ThreadLocal 线程局部变量

 

 

1.对某个对象加锁

♣ 例1.1：new一个对象作为锁

/**
 * sychronized关键字
 * 对某个对象加锁
 */
public class SyncronizeObject {
    private int count = 10;
    private Object o = new Object();

    public void m() {
        synchronized(o) {  //任何线程要执行下面的代码，必须要先拿到o的锁
            count -- ;
            System.out.println(Thread.currentThread().getName()+"count = " + count);
        }
    }

Java高并发编程 （马士兵老师视频）笔记（一）同步器_第1张图片

 

例1 中，这把锁是自己new的，每次new出一个毫无其他功能的对象就当锁的对象比较麻烦。所以可以用synchronized(this)。

♣ 例1.2：锁定自身对象

public class SynchronizeThis {
    private int count = 10;
    public void m1() {
        synchronized (this) {  //任何线程要执行下面的代码，必须先拿到this的锁
            count -- ;
            System.out.println(Thread.currentThread().getName() + "count = " + count);
        }
    }
    //m1()等同于下面的m2()
    public synchronized void m2() {  //等同于在方法的代码执行时要synchronized(this)
        count -- ;
        System.out.println(Thread.currentThread().getName() + "count = " +count);
    }
}

 

♣ 例1.3：synchronized用在静态方法上

package cn.xx55xx.concurrence;
/*类中静态方法和静态属性属性是不需要new出对象来访问的，没有new出来，就没有this引用的存在，
  所以当锁定一个静态方法时，相当于锁定的是当前类的class对象*/
public class SynchronizedStaticMethod {
    private  static int count = 10;
    //等同于synchronized(cn.xx55xx.concurrence.SynchronizedStaticMethod.class)
    public synchronized static void m1() {
        count --;
        System.out.println(Thread.currentThread().getName() + "count = " + count);
    }
    public static void m2() {
        synchronized (SynchronizedStaticMethod.class) { //*.class是Class中的一个对象，这里是不能用synchronized(this)的
            count -- ;
        }
    }
 }

 

♣ 例1.4：锁住线程的run方法

public class SynchronizedThread implements Runnable{
    private int count = 10;
    @Override
    public synchronized void run() {
        count -- ;
        System.out.println(Thread.currentThread().getName() + " count = " + count);
    }

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

run方法不加synchronized时，可能会出现以下这些情况（还有别的可能）：

  因为不加synchronized，count--和打印语句中间，有可能有别的线程来执行count--，导致前后数据不一致。加了synchronized这两条语句相当于是一个原子操作，一个run方法执行完毕释放了锁，下一个线程才能拿到锁执行run方法！

 

♣ 例1.5：同步方法与非同步方法是否可以同时调用？—— 可以

/*同步方法与非同步方法是可以同时调用的。只有synchronized修饰的方法在运行过程中才需要申请锁，普通方法是不需要申请的*/
public class AsynAndSynMethod {
    public synchronized void m1() {  //同步方法
        System.out.println(Thread.currentThread().getName() + " m1.start... ");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+" m1 end");

    }
    public void m2() {  //非同步方法
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+" m2 ");
    }

    public static void main(String[] args) {
        AsynAndSynMethod t = new AsynAndSynMethod();
        new Thread(()->t.m1(),"t1").start();  //new Thread(t::m1,"t1").start();
        new Thread(()->t.m2(),"t2").start();  //new Thread(t::m2,"t2").start();
    }
}

执行结果：

 

♣ 例1.6：对业务写方法加锁，对业务读方法不加锁，容易产生脏读问题。

/*对业务写方法加锁，对业务读方法不加锁，容易产生脏读问题，读到在写的过程中还没有完成的数据，可以对读方法加锁*/
public class Account {
    String name;
    double balance; //账户余额为成员变量 默认为0.0

    public synchronized void set(String name, double balance) { //写
        this.name = name;
        try {
            Thread.sleep(2000); //2s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.balance = balance;
    }
    public double getBalance(String name) {  //读
        return this.balance;
    }

    public static void main(String[] args) {
        Account a = new Account();
        new Thread(()->a.set("张三",100.0)).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(a.getBalance("张三"));  //0.0
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(a.getBalance("张三"));  //100.0
    }
}

 

♣ 例1.7：一个同步方法可以调用另外一个同步方法吗——可以

/*一个同步方法可以调用另外一个同步方法。一个线程已经拥有某个对象的锁，再次申请的时候任然会得到该对象的锁，即synchronized获得的锁是可重入的。*/
public class SynMethodCallAnother {
    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.8：在继承中，子类重写的同步方法可以调用父类的同步方法

/*一个同步方法可以调用另外一个同步方法，一个线程已经拥有某个对象的锁，再次申请的时候仍然会得到锁的对象，即可重入的。
在继承中，子类同步方法可以调用父类的同步方法*/
public class CallSuperclassSynMethod {
    synchronized void m() {
        System.out.println("m start...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("m end");
    }

    public static void main(String[] args) {
        new Child().m();  //锁定的都是同一个对象（子类对象）
    }
}
class Child extends CallSuperclassSynMethod {
    @Override
    synchronized void m() {
        System.out.println("child m start");
        super.m();
        System.out.println("child m end");
    }
}

 

♣ 例1.9：出现异常，默认情况下锁会被释放，

/** 程序执行过程中，如果出现异常，默认情况锁会被释放，所以在并发处理的过程中，有异常要多加小心，不然会发生不一致的情况；
* 比如，在一个web application处理请求时，多个servlet线程共同访问同一个资源，这时如果异常处理不合适；
* 在第一个线程中抛出异常，其他线程就会进入同步代码区，有可能会访问到异常产生的数据，因此要非常小心地处理同步业务逻辑中的异常。*/
public class SynchronizedException {
    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) {
        SynchronizedException se = new SynchronizedException();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                se.m();
            }
        };
        new Thread(r, "t1").start();
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(r,"t2").start();
    }
}

t1遇到异常释放了锁，t2立刻拿到了这把锁。参看下图的执行结果：

Java高并发编程 （马士兵老师视频）笔记（一）同步器_第2张图片

 

2.volatile关键字——使一个变量在多个线程中可见

♣ 例2.1 volatile的可见性

/**volatile关键字，使一个变量在多个线程中可见；但是volatile并不能保证多个线程共同修改running变量时所带来不一致的问题，即volatile不能完全代替synchronized
 * A、B线程都用到一个变量，java默认是A线程中保留一份copy，这样如果线程B修改了该变量，则线程A未必知道。
 * 使用volatile关键字，会强制让所有的线程都去读变量的修改后的值。
 */
public class VolatileVisible {
    volatile boolean running = true;  //对比一下有无volatile的情况下，整个程序运行结果的区别
    void m() {
        System.out.println("m start");
        while(running) {  //死循环。只有running=false时，才能执行后面的语句

        }
        System.out.println("m end");
    }
    public static void main(String[] args) {
        VolatileVisible vt = new VolatileVisible();
        new Thread(vt::m,"t1").start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        vt.running = false;  //若running不被volatile关键字修饰时，线程“看不见”running被修改了
    }
}

Java高并发编程 （马士兵老师视频）笔记（一）同步器_第3张图片

 

volatile 只保证原子性，而 synchronized 既保证可见性又保证原子性，但是synchronized太“重”了（效率很低）！

 

♣ 例2.2  volatile不具备原子性

/*10个线程分别执行10000次count++，count是对象vna的成员变量，按理来说最终count=100000，
  但是最终每次执行结果都不一样，count一直小于100000，说明volatile不具备原子性*/
public class VolatileNoAtomic {
    volatile int count = 0;
    void m() {
        for(int i=0; i<10000; i++) {
            count ++ ;
        }
    }
    public static void main(String[] args) {
        VolatileNoAtomic vna = new VolatileNoAtomic();
        List threads = new ArrayList<>();
        for (int i=0; i<10; i++) {
            threads.add(new Thread(vna::m, "thread" + i));
        }
        threads.forEach(o->o.start());
        threads.forEach((o)->{
            try {
                //join()方法阻塞调用此方法的线程,直到线程t完成，此线程再继续。通常用于在main()主线程内，等待其它线程完成再结束main()主线程。
                o.join(); //相当于在main线程中同步o线程，o执行完了，main线程才有执行的机会
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(vna.count);
    }
}

                 ...  每次结果都不一样，不是预期的100000。

 

♣ 例2.3  synchronized既保证可见性又保证了原子性

/*上例中，可以用synchronized解决，synchronized可以保证可见性和原子性，volatile只能保证可见性*/
public class SynVisibleAndAtomic {
    int count = 0;
    synchronized void m() {  //m方法加了synchronized修饰，保证了原子性和可见性
        for (int i=0; i<10000; i++) {
            count ++ ;
        }
    }
    public static void main(String[] args) {
        SynVisibleAndAtomic sva = new SynVisibleAndAtomic();
        List threads = new ArrayList<>();
        for (int i=0; i<10; i++) {
            threads.add(new Thread( sva::m , "thread-" + i));
        }
        threads.forEach((o)->o.start());
        threads.forEach((o)-> {
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(sva.count); //100000
    }
}

 

♣例2.4 实现一个容器，提供两个方法add、size，线程1添加10个元素到容器，线程2监控元素的的个数，当个数为5个时，线程2提示并结束。

  ♣♣ 2.4.1 给容器list添加volatile

/*给list添加volatile之后，t2能够接到通知，但t2线程的死循环很浪费CPU*/
public class MyContainerVolatile {
    volatile List list = new ArrayList();
    public void add(Object o) {  //add
        list.add(o);
    }
    public int size() {   //size
        return list.size();
    }

    public static void main(String[] args) {
        MyContainerVolatile mcv = new MyContainerVolatile();
        new Thread( () -> {  //该线程负责往list里添加
           for (int i=0; i<10; i++) {
               mcv.add(new Object());
               System.out.print(" add-" + i);
               try {
                   Thread.sleep(500);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        },"t1").start();
        new Thread( () -> { //该线程一直监测list的size，直到size=5
            while(true) {  //一直监测着，很浪费CPU
                if(mcv.size() == 5) {  //此处未加同步，仍然可能会出现t1中又一次++为6了，才break
                    break;
                }
            }
            System.out.print(" t2结束 ");
        },"t2").start();
    }
}

上面的代码能解决问题，但t2线程的死循环很浪费CPU，影响性能！更优方法请参看下例：

 

  ♣♣ 2.4.2  使用wait()和notify()做到，wait释放锁，而notify不会释放锁

当线程执行wait()方法时候，会释放当前的锁，然后让出CPU，进入等待状态。

当 notify/notifyAll() 被执行时，会唤醒一个或多个正处于等待状态的线程，然后继续往下执行，直到执行完synchronized 代码块的代码或是中途遇到wait() ，再次释放锁。

/*wait会释放锁，notify则不会。t1中notify唤醒t2，本线程不会释放锁，会一直执行下去直至被wait或synchronized代码块结束*/
public class MyContainerWaitNotify {
    volatile List list = new ArrayList();
    public void add(Object o) {
        list.add(o);
    }
    public int size() {
        return list.size();
    }

    public static void main(String[] args) {
        MyContainerWaitNotify mcwn = new MyContainerWaitNotify();
        final Object lock = new Object();
        new Thread(()->{
            synchronized (lock) {
                System.out.print(" ***线程t2启动*** ");
                if (mcwn.size() != 5) {
                    try {
                        lock.wait();  //size不等于5时，就一直在那等着，直到被t1叫醒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.print(" ***线程t2结束*** ");
                lock.notify();  //通知t1继续执行
            }
        }, "t2").start();

        new Thread(()->{
            synchronized (lock) {
                for(int i=0; i<10; i++) {
                    mcwn.add(new Object());
                    System.out.print(" add-"  + i);
                    if (mcwn.size() == 5) {
                        lock.notify();  //唤醒另一个线程t2，本线程继续执行，直至synchronized包裹的代码块结束或者调用了wait
                        try {
                            lock.wait(); //释放锁，让t2得以执行
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"t1").start();
    }
}

上述使用wait和notify也解决了问题，但是有点过于复杂。java提供了门栓/门闩。

 

  ♣♣ 2.4.3 使用CountDownLatch（门闩）的await和countdown方法替代wait、notify方法来进行通知。

/*使用Latch（门栓）的await和countdown方法替代wait notify方法来进行通知。好处是通信方式简单，同时也可以指定等待时间。
* CountDownLatch不涉及锁定，当count的值为零时当前线程继续运行.
* 当不涉及同步，只涉及锁定，用synchronized+wait/notify就显得太重了。这时应该考虑CountDownLatch/cyclicbarrier/semephore.*/
public class MyContainerLatch {
    volatile List list = new ArrayList(); //添加volatile，使t2能够得到通知
    public void add(Object o) {
        list.add(o);
    }
    public int size() {
        return list.size();
    }

    public static void main(String[] args) {
        MyContainerLatch mcl = new MyContainerLatch();
        CountDownLatch latch = new CountDownLatch(1);  //当1变成0时，门就开了
        new Thread(() -> {
            System.out.print(" *t2启动* ");
            if (mcl.size() != 5) {
                try {
                    latch.await();  //等待不需要锁定一个对象
                    //latch.await(5000,TimeUnit.MILLISECONDS); //也可以指定等待时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.print(" *t2结束* ");
        },"t2").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            System.out.print(" *t1启动* ");
            for (int i=0; i<10; i++) {
                mcl.add(new Object());
                System.out.print(" add-" + i);
                if (mcl.size() == 5) {
                    latch.countDown(); //打开门闩，让t2得以执行。调用一次countDown，就减1
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.print(" *t1结束* ");

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

 

3.原子变量类（AtomXxx）

  原子变量类 (Atomics)是基于CAS实现的能够保障对共享变量进行read-modify-write更新操作的原子性和可见性的一组工具类。所谓的read-modify-write更新操作，是指对共享变量的更新不是一个简单的赋值操作，而是变量的新值依赖于变量的旧值，例如自增操作 “count++”。由于volatile无法保障自增操作的原子性，而原子变量类的内部实现通常借助一个volatile变量并保障对该变量的read-modify-write更新操作的原子性，因此它可以被看作增强型的volatile变量。原子变量类一共有12个，可以被分为4组：

Java高并发编程 （马士兵老师视频）笔记（一）同步器_第4张图片

 

AtomicXxx类本身是原子性的，但是不能保证多个方法连续调用是原子性的！在 java.util.concurrent.atomic 包中。

♣ 例3.1  原子性操作int类型——AtomicInteger

public class AtomicIntegerTest {
    AtomicInteger count = new AtomicInteger(0);
    void m() {
        for (int i=0; i<10000; i++) {
            count.incrementAndGet(); ////incrementAndGet()-先+1，再返回; getAndIncrement()-先返回，再+1
        }
    }
    public static void main(String[] args) {
        AtomicIntegerTest ait = new AtomicIntegerTest();
        List threads = new ArrayList<>();
        for (int i=0; i<10; i++) {
            threads.add(new Thread( ait::m , "thread" + i));
        }
        threads.forEach((o)->o.start());
        threads.forEach((o)->{
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(ait.count); //100000
    }
}

 

 

4.ReentrantLock-重入锁

    ReentrantLock重入锁，是实现Lock接口的一个类。在Java中通常实现锁有两种方式，一种是synchronized关键字，另一种是Lock。(synchronized在jdk1.5之后做了优化，性能提升了很多，只是使用ReentrantLock更灵活一些)。

synchronized和Lock的区别
tips synchronized（关键字） Lock（接口）
实现 基于JVM层面实现（JVM控制锁的获取和释放） 基于JDK层面实现（我们可以借助JDK源码理解）
使用 不用我们手动释放锁 需要手动上锁和释放锁（finally中unlock）
锁获取超时 不支持。拿不到锁就一直在那等着，等到“死”。 支持。可以设置超时时间，时间过了没拿到就放弃，即Lock可以知道线程有没有拿到锁。
获取锁响应中断 不支持。 支持。可以设置是否可以被打断。
释放锁的条件 满足一个即可：①占有锁的线程执行完毕②占有锁的线程异常退出③占有锁的线程进入waiting状态释放锁 调用unlock()方法
公平与否 非公平锁。（公平指的是哪个线程等的时间长就把锁交给谁） 默认为非公平锁，可以设置为公平锁（排队等候）。

 

 

 

 

 

 

 

 

 

 

 

♣ 例4.1 ReentrantLock可以用来代替synchronized

/* ReentrantLock用来替代synchronized
 * ReentrantLock必须要手动释放锁。使用synchronized锁定如果遇到异常，jvm会自动释放锁，但是Lock必须手动释放，因此常常在finally中释放锁*/
public class ReentrantLockTest1 {
    Lock lock = new ReentrantLock();
    void m1() {
        try {
            lock.lock();  //加锁  //相当于synchronized(this)
            for (int i=0; i<10; i++) {
                TimeUnit.SECONDS.sleep(1);
                System.out.print(" " + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();  //释放锁
        }
    }
    void m2() {
        lock.lock();  //加锁
        System.out.print(" m2()... ");
        lock.unlock();  //释放锁
    }

    public static void main(String[] args) {
        ReentrantLockTest1 r1 = new ReentrantLockTest1();
        new Thread(r1::m1).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(r1::m2).start();
    }
}

 

♣ 例4.2  ReentrantLock可以进行尝试锁定tryLock()

/*使用ReentrantLock可以进行尝试锁定tryLock();若无法锁定或在指定时间内无法锁定，线程可以决定是否等待*/
public class ReentrantLockTryLock {
    Lock lock = new ReentrantLock();
    void m1() {
        try {
            lock.lock();
            for (int i=0; i<10; i++) {
                TimeUnit.SECONDS.sleep(1);
                System.out.print(" " + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    /**
     * 使用tryLock进行尝试锁定，不管锁定与否，方法都将会继续执行，可以根据tryLock的返回值判定是否被锁定了
     * 可以指定tryLock的时间，由于tryLock(time)抛出异常，所以要注意unlock的处理，必须放到finally中。
     */
    void m2() {
        /* boolean locked = lock.tryLock();
        System.out.print("  m2..." + locked + "  ");
        if (locked) lock.unlock();  //false */  //不指定尝试时间

        boolean locked = false;
        try {
            locked = lock.tryLock(5,TimeUnit.SECONDS); //指定超时时间为5s
            System.out.println("  m2..." + locked + "  ");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ReentrantLockTryLock r1 = new ReentrantLockTryLock();
        new Thread(r1::m1).start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(r1::m2).start();
    }
}

 

 

♣ 例4.3  ReentrantLock可调用lockInterruptibly方法，对线程的interrupt方法作出响应，在一个线程等待的过程中，可以被打断。

/*ReentrantLock可调用lockInterruptibly()方法，对线程的interrupt()方法作出响应，在一个线程等待的过程中，可以被打断。
* ReentrantLock的lock()方法是不能被打断的，即锁用lock()方法锁定，线程调用interrupt()方法是毫无作用的*/
public class ReentrantLockInterruptibly {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();

        Thread t1 = new Thread(() -> {
            try {
                lock.lock();
                System.out.print("  t1 start...  ");
                TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);  //t1不停的运行，睡死了
                System.out.print("  t1 end...  ");
            } catch (InterruptedException e) {
                System.out.print(" t1-interrupted! ");
            } finally {
                lock.unlock();
            }
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            try {
                // lock.lock(); //不能对interrupt()方法作出响应
                lock.lockInterruptibly();  //也是上锁，但是可以对interrupt()方法作出响应
                System.out.print("  t2 start...  ");
                TimeUnit.SECONDS.sleep(5);
                System.out.print("  t2 end...   ");
            } catch (InterruptedException e) {
                System.out.println("  t2-interrupted!  ");
            } finally {
                lock.unlock();
            }
        });
        t2.start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.interrupt();  //打断t2的等待
    }
}

 

♣ 例4.4 ReentrantLock可以指定为共享锁

/*ReentrantLock可以指定为公平锁，构造方法中将fair属性设置为true即为公平锁，fair默认为false*/
public class ReentrantLockFair extends Thread {
    private static ReentrantLock lock = new ReentrantLock(true); //参数为true表示为公平锁，可对比输出结果

    @Override
    public void run() {
        for (int i=0; i<20; i++) {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "-获得锁 ");
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        ReentrantLockFair r1 = new ReentrantLockFair();
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r1);
        t1.start();
        t2.start();
    }
}

fair设置为true时，两个线程交替执行，如下图；  fair设置为false时，执行顺序是随机的，并不是谁等的时间长谁执行。

Java高并发编程 （马士兵老师视频）笔记（一）同步器_第5张图片                 

 

♣ 例4.5  写一个固定容量的同步容器，拥有put和get方法，以及getCount方法，能够支持2个生产者线程以及10个消费者线程的阻塞调用。

  ♣♣  4.5.1 使用wait和notify/notifyAll()来实现

/*写一个固定容量的同步容器，拥有put和get方法，以及getCount方法，能够支持2个生产者线程以及10个消费者线程的阻塞调用。
* wait和notifyAll方法来实习。*/
public class ProducerCustomerWaitNotifyAll {
    final private LinkedList list = new LinkedList();
    final private int MAX = 10; //最多十个元素
    private int count = 0;

    public synchronized void put(Object t) {
        while (list.size() == MAX) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        list.add(t);
        ++count;
        this.notifyAll(); //通知消费者进程进行消费
        //notify只叫醒一个，叫醒的可能还是生产者，所有线程一直wait，程序就卡死了，所以用notifyAll
    }
    public synchronized Object get() {
        Object t = null;
        while (list.size() == 0) {  //
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        t = list.removeFirst();
        count --;
        this.notifyAll();  //通知生产者进程进行生产
        return t;
    }

    public static void main(String[] args) {
        ProducerCustomerWaitNotifyAll pc = new ProducerCustomerWaitNotifyAll();
        for (int i=0; i<10; i++) {  //10个消费者
            new Thread(() -> {
               for (int j=0; j<5; j++) {  //每个消费者最多消费5个
                   System.out.println(pc.get());
               }
            },"c"+i).start();
        }
        //启动生产者线程
        for (int i=0; i<2; i++) { //2个生产者
            new Thread(() -> {
               for (int j=0; j<25; j++) {  //每个生产者最多生产25个
                   pc.put(Thread.currentThread().getName() + " " + j);
               }
            },"p"+i).start();
        }
    }
} 
  
 
 
  
 
 
  
  ♣♣  4.5.1 使用Lock和Condition来实现
 
  
/*使用Lock和Condition来实现生产者和消费者的同步容器，
相比使用wait/notifyAll,使用Conditionde的方式能更加精确地指定哪些线程被唤醒。*/
public class ProducerConsumerLockCondition {
    final private LinkedList list = new LinkedList<>();
    final private int MAX = 10;
    private int count = 0;

    private Lock lock = new ReentrantLock();
    private Condition producer = lock.newCondition();
    private Condition consumer = lock.newCondition();

    public void put(Object obj) {
        try {
            lock.lock();
            while (list.size() == MAX) {
                producer.await();
            }
            list.add(obj);
            ++count ;
            consumer.signalAll(); //通知消费者进行消费
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public Object get() {
        Object obj = null;
        try {
            lock.lock();
            while (count == 0) {
                consumer.await();
            }
            obj = list.removeFirst();
            count -- ;
            producer.signalAll();  //通知生产者进行生产
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return obj;
    }

    public static void main(String[] args) {
        ProducerConsumerLockCondition c = new ProducerConsumerLockCondition();
        for (int i=0; i<10; i++) {
            new Thread(()->{
                for (int j=0; j<5; j++) {
                    System.out.println(c.get());
                }
            },"c"+i).start();
        }
        //启动生产者线程
        for (int i=0; i<2; i++) { //2个生产者
            new Thread(() -> {
                for (int j=0; j<25; j++) {  //每个生产者最多生产25个
                    c.put(Thread.currentThread().getName() + " " + j);
                }
            },"p"+i).start();
        }
    }
} 
  
 
 
  
5.ThreadLocal 线程局部变量
 
  
/*ThreadLocal是使用空间换时间，synchronized是使用时间换空间。
* 比如在Hibernate中的session就存在于ThreadLocal中，避免Synchronized的使用
* 线程局部变量属于每个线程都有自己的，线程间不共享，互不影响*/
public class ThreadLocalTest {
    static ThreadLocal tL = new ThreadLocal<>(); //每个线程的tL互不影响

    public static void main(String[] args) {
        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(tL.get());
        }).start();

        new Thread(()-> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            tL.set(new Person());
        }).start();
    }

    static class Person {
        String name = "zhangsan";
    }
}
 
  
第二个线程设置了值，但是第一个线程get得到的是：，说明线程局部变量是互不影响的！
 
  
 
 
  
补充：
 
  
常用的并发工具类：
 
  
闭锁：CountDownLatch
 
  
　　闭锁允许一个线程或多个线程等待特定情况，同步完成线程中其他任务。
 
  
栅栏：CyclicBarrier
 
  
　　CyclicBarrier和CountDownLatch都可以协同多个线程，让指定数量的线程等待期他所有的线程都满足某些条件之后才继续执行。CyclicBarrier可以重复使用(reset)，而CountDownLatch只能够使用一次，如果还需要使用，必须重现new一个CountDownLatch对象。构造方法CyclicBarrier(int, Runnable) 所有线程达到屏障后，执行Runnable。
 
  
信号量：Semaphore
 
  
　　信号量用来控制同时访问特定资源的线程数量。
 
  
交换者：Exchanger
 
  
　　Exchanger 交换者用于在两个线程之间传输数据，被调用后等待另一个线程达到交换点，然后相互交互数据。
 
  
 
 
  
 
 
  
常用的并发容器（下一篇会详细讲到）：
 
  
ConcurrentHashMap：JDK1.7实现：分段锁；JDK1.8实现：元素(key)锁+链表+红黑树
 
  
SkipList：跳表自动随机维护一套索引，用于高效的索引List中的有序数据。
 
  
https://img-blog.csdn.net/20160820160017491?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
 
  
ConcurrentSkipListMap：TreeMap的并发实现
 
  
ConcurrentSkipListSet：TreeSet的并发实现
 
  
ConcurrentLinkedQueue：LinkedList的并发实现
 
  
CopyOnWriteArrayList：写时复制，在添加元素是，复制一个新的容器，在新容器中新增元素；读数据都在Old容器中操作，进行读写分离。数据一致性较弱，适合读多写少的场景。
 
  
CopyOnWriteArraySet：同上
 
  
 
 
  
 
 
  
下一篇：Java高并发编程 （马士兵老师视频）笔记（二）并发容器
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Java基础,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：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • python八股文面试题分享及解析(1)
                        Shawn________
python
                        
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
    
                    
    • 
                    
  • MYSQL面试系列-04
                        king01299
面试mysql面试
                        
    MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
    
                    
    • 
                    
  • Kafka 消息丢失如何处理？
                        架构文摘JGWZ
学习
                        
    今天给大家分享一个在面试中经常遇到的问题：Kafka消息丢失该如何处理？这个问题啊，看似简单，其实里面藏着很多“套路”。来，咱们先讲一个面试的“真实”案例。面试官问：“Kafka消息丢失如何处理？”小明一听，反问：“你是怎么发现消息丢失了？”面试官顿时一愣，沉默了片刻后，可能有点不耐烦，说道：“这个你不用管，反正现在发现消息丢失了，你就说如何处理。”小明一头雾水：“问题是都不知道怎么丢的，处理起来
    
                    
    • 
                    
  • 每日算法&面试题，大厂特训二十八天——第二十天（树）
                        肥学
⚡算法题⚡面试题每日精进java算法数据结构
                        
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
    
                    
    • 
                    
  • 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的运行
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4)
                        算法大师
华为od面试python
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）
                        算法大师
华为od面试python算法前端
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
    
                    
    • 
                    
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面
                        一个射手座的程序媛
程序员华为od面试职场和发展
                        
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）
                        算法大师
华为od面试python
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
    
                    
    • 
                    
  • 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)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • 2019考研 | 西交大软件工程
                        笔者阿蓉

                        
    本科背景：某北京211学校电子信息工程互联网开发工作两年录取结果：全日制软件工程学院分数：初试350+复试笔试80+面试85+总排名：100+从五月份开始脱产学习，我主要说一下专业课和复试还有我对非全的一些看法。【数学100+】张宇，张宇，张宇。跟着张宇学习，入门视频刷一遍，真题刷两遍，错题刷三遍。书刷N多遍。从视频开始学习，是最快的学习方法。5-7月份把主要是数学学好，8-9月份开始给自己每个周
    
                    
    • 
                    
  • 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）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                                
  • LeetCode[Math] - #66 Plus One
                                    Cwind
javaLeetCode题解AlgorithmMath
                                    
    原题链接：#66 Plus One 
  
要求： 
给定一个用数字数组表示的非负整数，如num1 = {1, 2, 3, 9}, num2 = {9, 9}等，给这个数加上1。 
注意： 
1. 数字的较高位存在数组的头上，即num1表示数字1239 
2. 每一位（数组中的每个元素）的取值范围为0~9 
  
难度：简单 
  
分析： 
题目比较简单，只须从数组
    
                                
    • 
                                
  • JQuery中$.ajax()方法参数详解
                                    AILIKES
JavaScriptjsonpjqueryAjaxjson
                                    
    url: 要求为String类型的参数，（默认为当前页地址）发送请求的地址。 
type: 要求为String类型的参数，请求方式（post或get）默认为get。注意其他http请求方法，例如put和    delete也可以使用，但仅部分浏览器支持。 
timeout: 要求为Number类型的参数，设置请求超时时间（毫秒）。此设置将覆盖$.ajaxSetup()方法的全局
    
                                
    • 
                                
  • JConsole & JVisualVM远程监视Webphere服务器JVM
                                    Kai_Ge
JVisualVMJConsoleWebphere
                                    
        JConsole是JDK里自带的一个工具，可以监测Java程序运行时所有对象的申请、释放等动作，将内存管理的所有信息进行统计、分析、可视化。我们可以根据这些信息判断程序是否有内存泄漏问题。 
　　使用JConsole工具来分析WAS的JVM问题，需要进行相关的配置。 
　　首先我们看WAS服务器端的配置. 
　　1、登录was控制台https://10.4.119.18
    
                                
    • 
                                
  • 自定义annotation
                                    120153216
annotation
                                    
    Java annotation 自定义注释@interface的用法  一、什么是注释  
 
    说起注释，得先提一提什么是元数据(metadata)。所谓元数据就是数据的数据。也就是说，元数据是描述数据的。就象数据表中的字段一样，每个字段描述了这个字段下的数据的含义。而J2SE5.0中提供的注释就是java源代码的元数据，也就是说注释是描述java源
    
                                
    • 
                                
  • CentOS 5/6.X 使用 EPEL YUM源
                                    2002wmj
centos
                                    
    CentOS 6.X 安装使用EPEL YUM源1. 查看操作系统版本[root@node1 ~]# uname -a Linux node1.test.com 2.6.32-358.el6.x86_64 #1 SMP Fri Feb 22 00:31:26 UTC 2013 x86_64 x86_64 x86_64 GNU/Linux [root@node1 ~]#
    
                                
    • 
                                
  • 在SQLSERVER中查找缺失和无用的索引SQL
                                    357029540
SQL Server
                                    
    --缺失的索引 
SELECT  avg_total_user_cost * avg_user_impact * ( user_scans + user_seeks ) AS PossibleImprovement ,  
        last_user_seek ,  
  
    
                                
    • 
                                
  • Spring3 MVC 笔记（二） —json+rest优化
                                    7454103
Spring3 MVC
                                    
    接上次的 spring mvc 注解的一些详细信息！ 
                         其实也是一些个人的学习笔记  呵呵！ 
 

    
                                
    • 
                                
  • 替换“\”的时候报错Unexpected internal error near index 1 \ ^
                                    adminjun
java“\替换”
                                    
    发现还是有些东西没有刻子脑子里,,过段时间就没什么概念了,所以贴出来...以免再忘... 
  
在拆分字符串时遇到通过 \ 来拆分，可是用所以想通过转义 \\ 来拆分的时候会报异常 
   
 
 public class Main {   
    
     /*
    
                                
    • 
                                
  • POJ 1035 Spell checker(哈希表)
                                    aijuans
暴力求解--哈希表
                                    
    /*
题意：输入字典，然后输入单词，判断字典中是否出现过该单词，或者是否进行删除、添加、替换操作，如果是，则输出对应的字典中的单词
要求按照输入时候的排名输出

题解：建立两个哈希表。一个存储字典和输入字典中单词的排名，一个进行最后输出的判重
*/

#include <iostream>
//#define 
using namespace std;
const int HASH =
    
                                
    • 
                                
  • 通过原型实现javascript Array的去重、最大值和最小值
                                    ayaoxinchao
JavaScriptarrayprototype
                                    
    用原型函数（prototype）可以定义一些很方便的自定义函数，实现各种自定义功能。本次主要是实现了Array的去重、获取最大值和最小值。 
实现代码如下： 
  
<script type="text/javascript">
	Array.prototype.unique = function() {
		var a = {};
		var le
    
                                
    • 
                                
  • UIWebView实现https双向认证请求
                                    bewithme
UIWebViewhttpsObjective-C
                                    
      
        什么是HTTPS双向认证我已在先前的博文 ASIHTTPRequest实现https双向认证请求 
中有讲述，不理解的读者可以先复习一下。本文是用UIWebView来实现对需要客户端证书验证的服务请求，网上有些文章中有涉及到此内容，但都只言片语，没有讲完全，更没有完整的代码，让人困扰不已。但是此知
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(Redis高级应用之事务处理、持久化操作、pub_sub、虚拟内存)
                                    bijian1013
redis数据库NoSQL
                                    
    3.事务处理 
        Redis对事务的支持目前不比较简单。Redis只能保证一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。当一个client在一个连接中发出multi命令时，这个连接会进入一个事务上下文，该连接后续的命令不会立即执行，而是先放到一个队列中，当执行exec命令时，redis会顺序的执行队列中
    
                                
    • 
                                
  • 各数据库分页sql备忘
                                    bingyingao
oraclesql分页
                                    
    ORACLE 
 
下面这个效率很低 
SELECT * FROM ( SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_FS_RETURN order by id desc) A ) WHERE RN <20; 
 
下面这个效率很高 
SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_
    
                                
    • 
                                
  • 【Scala七】Scala核心一：函数
                                    bit1129
scala
                                    
    1. 如果函数体只有一行代码，则可以不用写{},比如 
def print(x: Int) = println(x) 
一行上的多条语句用分号隔开，则只有第一句属于方法体，例如 
  
def printWithValue(x: Int) : String= println(x); "ABC" 
  
上面的代码报错，因为，printWithValue的方法
    
                                
    • 
                                
  • 了解GHC的factorial编译过程
                                    bookjovi
haskell
                                    
    GHC相对其他主流语言的编译器或解释器还是比较复杂的，一部分原因是haskell本身的设计就不易于实现compiler，如lazy特性，static typed，类型推导等。 
关于GHC的内部实现有篇文章说的挺好，这里，文中在RTS一节中详细说了haskell的concurrent实现，里面提到了green thread，如果熟悉Go语言的话就会发现，ghc的concurrent实现和Go有点类
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-LinkedHashMap
                                    BrokenDreams
LinkedHashMap
                                    
            前面总结了java.util.HashMap，了解了其内部由散列表实现，每个桶内是一个单向链表。那有没有双向链表的实现呢？双向链表的实现会具备什么特性呢？来看一下HashMap的一个子类——java.util.LinkedHashMap。 
      
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-抽象工厂模式-Abstract Factory
                                    bylijinnan
abstract
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 


package design.pattern;

/*
 * Abstract Factory Pattern
 * 抽象工厂模式的目的是：
 * 通过在抽象工厂里面定义一组产品接口，方便地切换“产品簇”
 * 这些接口是相关或者相依赖的
    
                                
    • 
                                
  • 压暗面部高光
                                    cherishLC
PS
                                    
    方法一、压暗高光&重新着色 
当皮肤很油又使用闪光灯时，很容易在面部形成高光区域。 
下面讲一下我今天处理高光区域的心得： 
皮肤可以分为纹理和色彩两个属性。其中纹理主要由亮度通道（Lab模式的L通道）决定，色彩则由a、b通道确定。 
处理思路为在保持高光区域纹理的情况下，对高光区域着色。具体步骤为：降低高光区域的整体的亮度，再进行着色。 
如果想简化步骤，可以只进行着色（参看下面的步骤1
    
                                
    • 
                                
  • Java VisualVM监控远程JVM
                                    crabdave
visualvm
                                    
    Java VisualVM监控远程JVM  
  
JDK1.6开始自带的VisualVM就是不错的监控工具. 
这个工具就在JAVA_HOME\bin\目录下的jvisualvm.exe, 双击这个文件就能看到界面 
  
通过JMX连接远程机器, 需要经过下面的配置: 
1. 修改远程机器JDK配置文件 (我这里远程机器是linux). 
   
    
                                
    • 
                                
  • Saiku去掉登录模块
                                    daizj
saiku登录olapBI
                                    
     
1、修改applicationContext-saiku-webapp.xml 
 
<security:intercept-url pattern="/rest/**" access="IS_AUTHENTICATED_ANONYMOUSLY" />  
<security:intercept-url pattern=&qu
    
                                
    • 
                                
  • 浅析 Flex中的Focus
                                    dsjt
htmlFlexFlash
                                    
    关键字：focus、 setFocus、 IFocusManager、KeyboardEvent 
 焦点、设置焦点、获得焦点、键盘事件 
 
 
 一、无焦点的困扰——组件监听不到键盘事件 
原因：只有获得焦点的组件（确切说是InteractiveObject）才能监听到键盘事件的目标阶段；键盘事件（flash.events.KeyboardEvent）参与冒泡阶段，所以焦点组件的父项（以及它爸
    
                                
    • 
                                
  • Yii全局函数使用
                                    dcj3sjt126com
yii
                                    
    由于YII致力于完美的整合第三方库，它并没有定义任何全局函数。yii中的每一个应用都需要全类别和对象范围。例如，Yii::app()->user;Yii::app()->params['name'];等等。我们可以自行设定全局函数，使得代码看起来更加简洁易用。(原文地址) 
我们可以保存在globals.php在protected目录下。然后，在入口脚本index.php的，我们包括在
    
                                
    • 
                                
  • 设计模式之单例模式二（解决无序写入的问题）
                                    come_for_dream
单例模式volatile乱序执行双重检验锁
                                    
                    在上篇文章中我们使用了双重检验锁的方式避免懒汉式单例模式下由于多线程造成的实例被多次创建的问题，但是因为由于JVM为了使得处理器内部的运算单元能充分利用，处理器可能会对输入代码进行乱序执行（Out Of Order Execute）优化，处理器会在计算之后将乱序执行的结果进行重组，保证该
    
                                
    • 
                                
  • 程序员从初级到高级的蜕变
                                    gcq511120594
框架工作PHPandroidhtml5
                                    
    软件开发是一个奇怪的行业，市场远远供不应求。这是一个已经存在多年的问题，而且随着时间的流逝，愈演愈烈。 
我们严重缺乏能够满足需求的人才。这个行业相当年轻。大多数软件项目是失败的。几乎所有的项目都会超出预算。我们解决问题的最佳指导方针可以归结为——“用一些通用方法去解决问题，当然这些方法常常不管用，于是，唯一能做的就是不断地尝试，逐个看看是否奏效”。 
现在我们把淫浸代码时间超过3年的开发人员称为
    
                                
    • 
                                
  • Reverse Linked List
                                    hcx2013
list
                                    
    Reverse a singly linked list. 
  
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
p
    
                                
    • 
                                
  • Spring4.1新特性——数据库集成测试
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • C# Ajax上传图片同时生成微缩图(附Demo)
                                    liyonghui160com

                                    
      
  
1.Ajax无刷新上传图片,详情请阅我的这篇文章。（jquery + c# ashx） 
        2.C#位图处理  System.Drawing。 
        3.最新demo支持IE7,IE8,Fir
    
                                
    • 
                                
  • Java list三种遍历方法性能比较
                                    pda158
java
                                    
    从c/c++语言转向java开发，学习java语言list遍历的三种方法，顺便测试各种遍历方法的性能，测试方法为在ArrayList中插入1千万条记录，然后遍历ArrayList，发现了一个奇怪的现象，测试代码例如以下： 
package com.hisense.tiger.list;
import java.util.ArrayList;
import java.util.Iterator;
    
                                
    • 
                                
  • 300个涵盖IT各方面的免费资源（上）——商业与市场篇
                                    shoothao
seo商业与市场IT资源免费资源
                                    
     
 A.网站模板+logo+服务器主机+发票生成 
 
 
  HTML5 UP:响应式的HTML5和CSS3网站模板。 
  Bootswatch:免费的Bootstrap主题。 
  Templated:收集了845个免费的CSS和HTML5网站模板。 
  Wordpress.org|Wordpress.com:可免费创建你的新网站。 
  Strikingly:关注领域中免费无限的移动优
    
                                
    • 
                                
  • localStorage、sessionStorage
                                    uule
localStorage
                                    
    W3School 例子 
  
HTML5 提供了两种在客户端存储数据的新方法： 
localStorage - 没有时间限制的数据存储 
sessionStorage - 针对一个 session 的数据存储 
  
之前，这些都是由 cookie 完成的。但是 cookie 不适合大量数据的存储，因为它们由每个对服务器的请求来传递，这使得 cookie 速度很慢而且效率也不
    
                                
    •