读书小旺仔
读书小旺仔

JUC并发编程引导学习（超长篇）

JUC并发编程学习

1、什么是JUC

juc是Java并发编程的一个工具包，包名为java.util.concurrent

2、进程和线程

  • 进程是资源分配的基本单位，线程是CPU调度的最小单位
  • 一个进程由一个或多个线程组成
  • 进程的资源由系统进行分配，线程间共享进程的所有资源
  • 进程有自己的独立空间，线程没有自己的独立空间
  • 进程切换比线程切换开销大

3、线程的六种状态

通过Thread.state源码可知，线程共有6种状态：新建、运行、等待、延时等待、阻塞、结束

public enum State {
        
          //新建
        NEW,

        //运行
        RUNNABLE,

        //阻塞
        BLOCKED,

        //等待
        WAITING,

        //延时等待
        TIMED_WAITING,

        //结束
        TERMINATED;
    }

4、wait和sleep区别

  • wait对象是Object，sleep对象是Thread（this.wait(),Thread.sleep()）
//线程休眠推荐使用TimeUnit，可以直观地显示休眠时间单位
TimeUnit.SECONDS.sleep(2);
TimeUnit.DAYS.sleep(1);
//TimeUnit本质调用的也还是Thread.sleep(),但Thread.sleep()参数以毫秒为单位，使用枚举类型TimeUnit,能清晰表述时间
  • sleep休眠期间不会释放锁，wait等待期间会释放锁
  • wait和notify结合使用，等待后需要notify唤醒，sleep单独使用，时间过了就可以
  • sleep需要捕获异常

5、Lock

1、锁的概念

​ 锁是拿来控制多个线程对共享资源的访问。访问共享资源时，只允许一个线程拥有锁，业务结束后再释放锁，下一个线程再获取锁...以此保证线程并发安全。

2、传统的synchronized

package com.zxw.jucproject.module.demo;

/**
 * 使用传统的synchronized解决并发问题
 */
public class Demo1 {

    public static void main(String[] args) {

        Ticket ticket = new Ticket();

        new Thread(()->{
            for (int i = 0; i < 20; i++){
                ticket.sendTicket();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 20; i++){
                ticket.sendTicket();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 20; i++){
                ticket.sendTicket();
            }
        },"C").start();


    }

}

/**
 * 资源类
 */
class Ticket{

    /**
     * 总票数量
     */
    private int ticketCount = 30;
    //synchronized 是一个关键字
    public synchronized void sendTicket(){
       if (ticketCount > 0){
            ticketCount--;
            System.out.println(Thread.currentThread().getName()+"顾客购买了票，票还剩余:"+ticketCount);
        }
    }
}

3、Lock锁ReentrantLock

package com.zxw.jucproject.module.demo;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 使用Lock锁解决并发问题
 */
public class Demo2 {

    public static void main(String[] args) {

        Ticket2 ticket = new Ticket2();

        new Thread(()->{
            for (int i = 0; i < 20; i++){
                ticket.sendTicket();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 20; i++){
                ticket.sendTicket();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 20; i++){
                ticket.sendTicket();
            }
        },"C").start();


    }

}

/**
 * 资源类
 */
class Ticket2{

    /**
     * 总票数量
     */
    private int ticketCount = 30;
    //Lock是一个对象
    //可重入锁
    //ReetrantLock（）默认是一个非公平锁，new ReentrantLock(ture)可实现公平锁
    private Lock lock = new ReentrantLock();

    public  void sendTicket(){
        //加锁
        lock.lock();
        try {
            if (ticketCount > 0){
                ticketCount--;
                System.out.println(Thread.currentThread().getName()+"顾客购买了票，票还剩余:"+ticketCount);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }
    }
}

4、Lock和synchronized的区别

  • Lock是一个对象，synchronize是关键字
  • synchronized是非公平锁，lock默认是非公平锁，但构造方法参数填true可实现公平锁
  • Lock需要手动释放锁，synchronized自动释放锁
  • Lock在线程阻塞时可以尝试解锁（lock.tryLock()），synchronized则必须等待
  • 在代码量比较复杂的情况下，通常使用Lock锁进行精准锁住关键业务代码。synchronized通常使用简单的业务代码

5、生产者和消费者问题

生产者和消费者问题是典型的多线程并发协作问题，通常是指生产者和消费者共同操作一个资源，并且该资源只有在生产者生产后，消费者才自动去消费。消费者消费完生产者的数据后，生产者才生产。

传统的synchronized。

有一个公共资源x=0，实现依次A线程+1，B线程-1 10次

如果资源判断是使用if时，会出现虚假唤醒，导致该模式无法实现4个线程依次执行+1-1+1-1

public class Demo3 {

    public static void main(String[] args){

        ResourceNumber resourceNumber = new ResourceNumber();
        new Thread(()->{
            for (int i = 0; i < 10; i++){
                try {
                    resourceNumber.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++){
                try {
                    resourceNumber.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }

}

/**
 * 资源类
 * 线程之间通信主要三步走
 * 1、判断
 * 2、执行
 * 3、通知
 */
class ResourceNumber{

    private int num = 0;

    public synchronized void increment() throws InterruptedException {

        //如果num不等于0，则线程等待（1、判断）
        if (num != 0){
            this.wait();
        }
        //2、执行
        num++;
        System.out.println(Thread.currentThread().getName()+":"+num);
        //唤醒所有等待的线程（3、通知）
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {

        if (num != 1){
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName()+":"+num);
        this.notifyAll();
    }

}

传统的synchronized。

有一个公共资源x=0，实现依次四个线程依次+1-1+1-1

但无法实现A线程+1之后B线程-1之后C线程+1之后D线程-1

public class Demo3 {

    public static void main(String[] args){

        ResourceNumber resourceNumber = new ResourceNumber();
        new Thread(()->{
            for (int i = 0; i < 10; i++){
                try {
                    resourceNumber.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++){
                try {
                    resourceNumber.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++){
                try {
                    resourceNumber.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++){
                try {
                    resourceNumber.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }

}

/**
 * 资源类
 * 线程之间通信主要三步走
 * 1、判断
 * 2、执行
 * 3、通知
 */
class ResourceNumber{

    private int num = 0;

    public synchronized void increment() throws InterruptedException {

        //如果num不等于0，则线程等待（1、判断）
        while (num != 0){
            this.wait();
        }
        //2、执行
        num++;
        System.out.println(Thread.currentThread().getName()+":"+num);
        //唤醒所有等待的线程（3、通知）
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {

        while (num != 1){
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName()+":"+num);
        this.notifyAll();
    }

}

Lock锁实现精准唤醒线程,实现依次A+1，B-1，C+1，D-1

package com.zxw.jucproject.module.demo;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 生产者和消费者问题-即多线程并发协作的问题。
 * 使用Lock ReenstrantLock精准唤醒线程
 */
public class Demo4 {

    public static void main(String[] args){

        ResourceNumber2 resourceNumber = new ResourceNumber2();
        new Thread(()->{
            for (int i = 0; i < 10; i++){
                try {
                    resourceNumber.incrementA();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++){
                try {
                    resourceNumber.decrementB();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++){
                try {
                    resourceNumber.incrementC();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++){
                try {
                    resourceNumber.decrementD();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }

}

/**
 * 资源类
 * 线程之间通信主要三步走
 * 1、判断
 * 2、执行
 * 3、通知
 */
class ResourceNumber2{

    private int num = 0;

    private Lock lock = new ReentrantLock();
    Condition A = lock.newCondition();
    Condition B = lock.newCondition();
    Condition C = lock.newCondition();
    Condition D = lock.newCondition();


    public void incrementA() throws InterruptedException {

        lock.lock();
        try {
            //如果num不等于0，则线程等待（1、判断）
            while (num != 0){
                A.await();
            }
            //2、执行
            num++;
            System.out.println(Thread.currentThread().getName()+":"+num);
            //唤醒所有等待的线程（3、通知）
            B.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void decrementB() throws InterruptedException {
        lock.lock();
        try {
            while (num != 1){
                B.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+":"+num);
            C.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void incrementC() throws InterruptedException {
        lock.lock();
        try {
            //如果num不等于0，则线程等待（1、判断）
            while (num != 0){
                C.await();
            }
            //2、执行
            num++;
            System.out.println(Thread.currentThread().getName()+":"+num);
            //唤醒所有等待的线程（3、通知）
            D.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void decrementD() throws InterruptedException {
        lock.lock();
        try {
            while (num != 1){
                D.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+":"+num);
            A.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

6、八锁问题

解决八锁问题只需要记住以下关键信息

  • 被synchronized修饰的方法，方法调用者即为锁拥有者
  • 被static修复的方法，方法所属对象即为锁拥有者
  • 被static和synchronized修饰的方法，方法所属对象即为锁拥有者
  • 普通方法，不受锁的控制

若多个线程的锁拥有者为同一个，则其中一个获得锁，还未解锁，其余线程则等待；若多个线程的锁拥有者不为同一个，则互不影响；若线程无锁，则也不会受到其他线程锁的影响

7、并发不安全的集合类

list、set、map并发情况下都不安全

list需要用CopyOnWriteArrayList实现线程安全

set需要用CopyOnWriteArraySet实现线程安全

map需要用concurrentHashMap实现线程安全

CopyOnWriteArrayList和CopyOnWriteArraySet底层除了加锁外，还在操作时会新建一个数组，在新建的数组上进行操作，然后替换之前的数组，保证数据安全。

8、ReadWriteLock读写锁

package com.zxw.jucproject.module.lock;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
* 读写锁WriteReadLock(Interface)
* 独立锁（写锁）:只允许一个线程执行，保持事务的原子性
* 共享锁（读锁）:可以允许多个线程执行
*/
public class ReadWriteLockDemo {

 public static void main(String[] args) {

     //Catch aCatch = new Catch();
     CatchLock aCatch = new CatchLock();

     //写数据线程
     for (int i = 0; i < 10; i++){
         final int tmp = i;
         new Thread(()->{
             aCatch.put(String.valueOf(tmp),String.valueOf(tmp));
         },"线程A"+i).start();
     }
     //读数据线程
     for (int i = 0; i < 10; i++){
         final int tmp = i;
         new Thread(()->{
             aCatch.get(String.valueOf(tmp));
         },"线程B"+i).start();
     }
 }


}

/**
* 该资源调用可以看出：
* 写数据过程没有保证原子性，还没结束写入数据，其他线程就开始写入了。所以需要加锁
*/
class Catch{

 private ConcurrentMap map = new ConcurrentHashMap<>();

 //写数据
 public void put(String key ,String value){
     System.out.println(Thread.currentThread().getName()+":-> 开始写入数据(key="+key+",value="+value+")");
     map.put(key,value);
     System.out.println(Thread.currentThread().getName()+":-> 结束写入数据");
 }
 //读数据
 public void get(String key){
     System.out.println(Thread.currentThread().getName()+":-> 开始读取数据(key="+key+")");
     String value = map.get(key);
     System.out.println(Thread.currentThread().getName()+":-> 结束读取数据(value="+value+")");
 }

}

/**
*
* 读写锁控制写资源时保证原子性，读资源时，随意读取资源
*/
class CatchLock{

 private ConcurrentMap map = new ConcurrentHashMap<>();
 private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

 //写数据
 public void put(String key ,String value){

     readWriteLock.writeLock().lock();
     try {
         System.out.println(Thread.currentThread().getName()+":-> 开始写入数据(key="+key+",value="+value+")");
         map.put(key,value);
         System.out.println(Thread.currentThread().getName()+":-> 结束写入数据");
     } catch (Exception e) {
         e.printStackTrace();
     } finally {
         readWriteLock.writeLock().unlock();
     }
 }
 //读数据
 public void get(String key){

     readWriteLock.readLock().lock();

     try {
         System.out.println(Thread.currentThread().getName()+":-> 开始读取数据(key="+key+")");
         String value = map.get(key);
         System.out.println(Thread.currentThread().getName()+":-> 结束读取数据(value="+value+")");
     } catch (Exception e) {
         e.printStackTrace();
     } finally {
         readWriteLock.readLock().unlock();
     }
 }

}

9、阻塞队列

1、首先什么时候队列会阻塞？

  • 想把数据放入队列，但是队列满了，则会导致阻塞
  • 想从队列中取出数据，但是队列是空的，则会导致阻塞

2、阻塞后会采取什么操作

  • 抛出异常
  • 不抛出异常，返回false或者自定义信息
  • 无限期阻塞进程，直到操作成功为止
  • 设定阻塞后等待时间，等时间一过还没操作成功则放弃

3、具体实现方法

插入方法 移除方法 阻塞后操作
Add(e) Poll 抛出异常
offer(e) Poll 不抛出异常，丢弃数据，返回false
put(e) take(e) 一直等待
offer(e,t,unit) Poll 等待t时间后丢弃数据 
package com.zxw.jucproject.module.queue;

import java.util.ArrayDeque;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * 阻塞队列
 */
public class BlockQueueDemo {

    public static void main(String[] args) throws InterruptedException {

       // commonQueueDemo();

       // blockQueueDemo01();

       // blockQueueDemo02();

       //  blockQueueDemo03();

        blockQueueDemo04();

    }


    /**
     * 当队列阻塞后设置阻塞等待时间，超过等待时间后，抛弃数据
     * @throws InterruptedException
     */
    public static void blockQueueDemo04() throws InterruptedException {

        ArrayBlockingQueue queue = new ArrayBlockingQueue<>(3);
        System.out.println(queue.offer("a",5, TimeUnit.SECONDS));
        System.out.println(queue.offer("b"));
        System.out.println(queue.offer("c"));
        System.out.println(queue.offer("d",5, TimeUnit.SECONDS));

        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());

    }

    /**
     * 队列阻塞后一直等待，直到能成功把数据插入即可
     *保留一个问题：
     * 试了好多种方法，好像队列阻塞后，就没有方法让它唤醒嘛？使用remove移除数据或者clean清除数据都不好使？？
     */
    public static void blockQueueDemo03() throws InterruptedException {

        ArrayBlockingQueue queue = new ArrayBlockingQueue<>(3);
        queue.put("a");
        queue.put("b");
        queue.put("c");
        queue.put("d");

        System.out.println(queue.take());
        System.out.println(queue.take());
        System.out.println(queue.take());

    }

    /**
     * 队列阻塞后不抛出异常，丢弃数据，返回false状态
     *
     */
    public static void blockQueueDemo02(){

        ArrayBlockingQueue queue = new ArrayBlockingQueue<>(3);
        System.out.println(queue.offer("a"));
        System.out.println(queue.offer("b"));
        System.out.println(queue.offer("c"));
        System.out.println(queue.offer("d"));

        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());

    }

    /**
     * 队列阻塞后抛出异常
     * Exception in thread "main" java.lang.IllegalStateException: Queue full
     */
    public static void blockQueueDemo01(){

        ArrayBlockingQueue queue = new ArrayBlockingQueue<>(3);
        queue.add("a");
        queue.add("b");
        queue.add("c");
        queue.add("d");

        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());

    }
    /**
     * 普通队列实现，普通队列的存储都是可扩充的。
     * 看源码学习扩容机制
     */
    public static void commonQueueDemo(){

        ArrayDeque deque = new ArrayDeque<>(3);
        deque.add("a");
        deque.add("b");
        deque.add("c");
        deque.add("d");

        System.out.println(deque.poll());
        System.out.println(deque.poll());
        System.out.println(deque.poll());
        System.out.println(deque.poll());
    }
}


package com.zxw.jucproject.module.queue;


import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/**
 * SynchronousQueue只有一个元素队列，每一个插入操作都得等待另一个线程的删除操作。
 * 注意：
 *     1、当队列中已经存在一个元素即队列已满时，再插入数据后队列会阻塞
 *     2、当队列不存在数据时，去读取数据，队列不会阻塞，读取null
 */
public class SynchronousQueueDemo {

    public static void main(String[] args) {

        SynchronousQueue queue = new SynchronousQueue<>();

        new Thread(()->{
            try {
                System.out.println("放入a");
                queue.put("a");
                System.out.println("放入b");
                queue.put("b");
                System.out.println("放入c");
                queue.put("c");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(()->{
            try {

            TimeUnit.SECONDS.sleep(3);
            System.out.println("取出"+queue.poll());

            TimeUnit.SECONDS.sleep(3);
            System.out.println("取出"+queue.poll());

            TimeUnit.SECONDS.sleep(3);
            System.out.println("取出"+queue.poll());
            System.out.println("取出"+queue.poll());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

    }
}

 
 
10、线程池
 
 
池技术广泛应用、譬如线程池、连接池、内存池等，池技术主要是为了充分利用资源，避免资源浪费，以及减少资源连接和关闭时间消耗，提高程序性能
 
 
 
  
线程池10个问题：https://www.cnblogs.com/konck/p/9473681.html
 
 
 
 
1、线程池模型介绍
 
 
 
  
 
   
 
    JUC并发编程引导学习（超长篇）_第1张图片 
   
 
  
 
  

    image-20200305213739805.png 
  
 
 
 
 
2、Executors弊端
 
 
//单例线程池，只有一个线程
ExecutorService threadPool1 = Executors.newSingleThreadExecutor();

/* 源码
*  new LinkedBlockingQueue()创建Integer.MAX_VALUE大的队列空间
*  若出现大量请求，则堆积的大量请求队列会耗费非常大的内存，甚至OOM
**/
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue()));
    }

//根据需要变化的线程池
ExecutorService threadPool2 = Executors.newCachedThreadPool();

/**
* 源码
* new SynchronousQueue()是容量只有1个的阻塞队列，所以不会堆积大量请求，但是
* 最大线程数(maximumPoolSize) = Integer.MAX_VALUE ,若出现大量请求，会创造大量的线程，导致OOM
*/
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue());
    }

//自定义线程数线程池
ExecutorService threadPool3 = Executors.newFixedThreadPool(5);
//造成OOM的原因和Executors.newSingleThreadExcutor()一样

 
 
3、ThreadPoolExecutor源码
 
 
 
 /**
     * 创建线程池初始方法
     *
     * @param corePoolSize 核心线程池数量
     * @param maximumPoolSize 最大线程池数量-(cpu核数)
     * @param keepAliveTime 超时等待时长
     * @param unit 超时等待时长单位
     * @param workQueue 阻塞队列
     * @param threadFactory 线程工厂
     * @param handler 拒绝策略
     */
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

 
 
4、应用ThreadPoolExecutor
 
 
package com.zxw.jucproject.module.pool;
import java.util.concurrent.*;

/**
 * 线程池介绍
 *
 */
public class ThreadPoolDemo {


    public static void main(String[] args) {

        //核心线程3个，每一个线程执行大约100ms，客户最多等待3s，那么阻塞队列数量可这么设定=3s/3/100ms=10个

        //new ThreadPoolExecutor.AbortPolicy() 拒绝策略，当总线程数和阻塞队列都满后，会抛出异常
        //ThreadPoolExecutor thread = new ThreadPoolExecutor(3,4,3L, TimeUnit.SECONDS,new LinkedBlockingDeque<>(10),Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

        //线程阻塞后使用当前方法的进程来调用即main方法
       // ThreadPoolExecutor thread = new ThreadPoolExecutor(3,4,3L, TimeUnit.SECONDS,new LinkedBlockingDeque<>(10),Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy());

        //new ThreadPoolExecutor.DiscardOldestPolicy() 丢弃最旧的数据，执行刚拒绝的
       //ThreadPoolExecutor thread = new ThreadPoolExecutor(3,4,3L, TimeUnit.SECONDS,new LinkedBlockingDeque<>(10),Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardOldestPolicy());

        //阻塞的直接丢弃
        ThreadPoolExecutor thread = new ThreadPoolExecutor(3,4,3L, TimeUnit.SECONDS,new LinkedBlockingDeque<>(10),Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardPolicy());

        try {
            for (int i = 0; i < 100; i++){
                final int tmp = i;
                thread.execute(()->{
                    System.out.println(Thread.currentThread().getName()+":"+tmp);
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            thread.shutdown();
        }

    }

    public static void main01(String[] args) {

        /**
         * 不推荐使用Excutors创建线程池，会出现内存泄漏情况OOM
         */
        //单线程池
        ExecutorService threadPool1 = Executors.newSingleThreadExecutor();
        //根据需要变化的线程池
        ExecutorService threadPool2 = Executors.newCachedThreadPool();
        //自定义线程数线程池
        ExecutorService threadPool3 = Executors.newFixedThreadPool(5);

        try {
//        for (int i = 0; i < 10; i++){
//            threadPool1.execute(()->{
//                System.out.println(Thread.currentThread().getName());
//            });
//        }


//        for (int i = 0; i < 10; i++){
//            threadPool2.execute(()->{
//                System.out.println(Thread.currentThread().getName());
//            });
//        }


            for (int i = 0; i < 10; i++){
                threadPool3.execute(()->{
                    System.out.println(Thread.currentThread().getName());
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //使用结束后需要关闭
            threadPool3.shutdown();
        }


    }


}

 
 
5、拒绝策略源码剖析
 
 
1、拒绝任务后抛出异常
 
 
    /**
     * 任务拒绝后抛出异常，数据也丢失
     */
    public static class AbortPolicy implements RejectedExecutionHandler {
        /**
         * Creates an {@code AbortPolicy}.
         */
        public AbortPolicy() { }

        /**
         * Always throws RejectedExecutionException.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         * @throws RejectedExecutionException always
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }

 
 
2、直接丢弃拒绝任务
 
 
    /**
     * 直接丢弃拒绝任务
     */
    public static class DiscardPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code DiscardPolicy}.
         */
        public DiscardPolicy() { }

        /**
         * Does nothing, which has the effect of discarding task r.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }


 
 
3、丢弃在队列中等待最久的数据
 
 
  /**
     * 丢弃等待最久的数据
     */
    public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code DiscardOldestPolicy} for the given executor.
         */
        public DiscardOldestPolicy() { }

        /**
         * Obtains and ignores the next task that the executor
         * would otherwise execute, if one is immediately available,
         * and then retries execution of task r, unless the executor
         * is shut down, in which case task r is instead discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }


 
 
4、使用当前方法的线程运行
 
 
  /**
     * 使用当前方法的线程运行拒绝任务，通常为main线程
     */
    public static class CallerRunsPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code CallerRunsPolicy}.
         */
        public CallerRunsPolicy() { }

        /**
         * Executes task r in the caller's thread, unless the executor
         * has been shut down, in which case the task is discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }
    }

 
 
6、最大线程池如何设定
 
 
     
  
  • CPU密集型： cpu核数就是最大的线程数
    •  
  
  • IO密集型： 譬如50个IO都是常用的IO资源，要设置大于常用的IO线程数
    •  
 
 
 
11、四大函数式接口
 
 
 
  
4大函数式接口，通常可以用lambda表达式或者方法的引用赋值对象
 
  
lambda表达式更简单，使用lambda代替方法的引用赋值对象
 
 
 
 
1、Function-apply
 
 
package com.zxw.jucproject.module.function;


import java.util.function.Function;

/**
 * function要求两个参数，一个输入参数，一个输出参数 apply()
 */
public class FunctionDemo {

    public static void main(String[] args) {

        //使用传统的引用对象赋值
        Function function = new Function() {
            @Override
            public Integer apply(String str) {
                return str.length();
            }
        };
        System.out.println(function.apply("hello world"));

        //函数式接口使用lambda表达式
        Function function1 = (s)->{
            return s.length();
        };
        System.out.println(function1.apply("hello world"));

    }
}


 
 
2、Consumer-accept
 
 
package com.zxw.jucproject.module.function;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

/**
 * Consumer 要求一个参数，输入参数，没有返回值 方法：accept()
 */
public class ConsumeDemo {

    public static void main(String[] args) {

        List list = new ArrayList<>();

        //使用传统的引用对象赋值
        Consumer consumer = new Consumer() {
            @Override
            public void accept(String o) {
                list.add(o);
            }
        };
        consumer.accept("hello");
        System.out.println(list);

        //使用lambda表达式赋值
        Consumer consumer1 = (s) -> {list.add(s);};
        consumer1.accept("world");
        System.out.println(list);
    }
}


 
 
3、Predicate-test
 
 
package com.zxw.jucproject.module.function;

import java.util.function.Predicate;

/**
 * Predicate 要求一个参数，输入参数，返回Boolean类型 test()
 */
public class PredicateDemo {

    public static void main(String[] args) {

        //使用传统的引用赋值
        Predicate predicate = new Predicate() {
            @Override
            public boolean test(String o) {
                return o.length()==5;
            }
        };
        System.out.println(predicate.test("hello"));

        //使用lambda表达式赋值
        Predicate predicate1 = (s)->{return s.length() == 5;};
        System.out.println(predicate1.test("world"));
    }
}


 
 
4、Supplier-get
 
 
package com.zxw.jucproject.module.function;

import java.util.function.Supplier;

/**
 * Supplier 不需要参数，有返回值 get()
 */
public class SupplierDemo {

    public static void main(String[] args) {

        //使用传统的引用赋值
        Supplier supplier = new Supplier() {
            @Override
            public Object get() {
                return "hello";
            }
        };

        System.out.println(supplier.get());

        //使用lambda表达式
        Supplier supplier1 = ()->{return "world";};
        System.out.println(supplier1.get());

    }
}


 
 
12、Stream流式计算
 
 
 
  
注意看源码，尤其是参数和返回值
 
 
 
 
package com.zxw.jucproject.module.stream;

import java.util.*;
import java.util.stream.Collectors;

public class StreamDemo {

    /**
     *
     * @param args
     */
    public static void main(String[] args) {

        /**
         * 给出一个任务，筛选出
         *  成绩大于等于60分并且
         *  年龄小于16岁并且
         *  性别是女孩
         *  的同学，并且按成绩从高到低排名
         *
         *  用一行表达式解决
         */
        Student s1 = new Student("张三",15,"abc",60,"man");
        Student s2 = new Student("里斯",18,"del",80,"women");
        Student s3 = new Student("小屋",11,"ef",67,"women");
        Student s4 = new Student("老刘",16,"xa",45,"man");
        Student s5 = new Student("小巴",13,"axk",50,"women");
        Student s6 = new Student("老旧",9,"sej",92,"women");

        List students = Arrays.asList(s1, s2, s3, s4, s5, s6);
        /**
         * 学习：
         * Student::getScore 是lambda的缩写   等价于 (s)->{return s.getSocre();}
         * filter : 筛选出满足条件的对象，返回仍是Stream
         * sorted: 排序。Comparator.comparing(Student::getScore)根据分数正向排序,返回Stream
         * map: 对指定属性进行操作，返回指定属性的类型：.map(s->{return s.getCourse().toUpperCase();})将返回Stream 看源码可知
         * 
         */
        List list = students.stream().filter(s -> (s.getScore() >= 60 && s.getSex().equals("women") && s.getAge() < 16)).sorted(Comparator.comparing(Student::getScore).reversed()).collect(Collectors.toList());
        list.forEach(s->{System.out.println(s.toString());});


    }
}


 
 
13、分支合并ForkJoin
 
 
ForkJoin实现原理递归，大数据量下计算比普通方法效率高，但不如流计算
 
 
package com.zxw.jucproject.module.forkjoin;

import java.util.concurrent.RecursiveTask;

public class ForkJoinDemo extends RecursiveTask {

    private Long start;
    private Long end;
    private final static Long tempFlag = 10000L;

    ForkJoinDemo(Long start,Long end){
        this.start = start;
        this.end  = end;
    }

    @Override
    protected Long compute() {
        //临界值
        if ((end-start)
 
 
普通方法、forkjoin方法、流计算方法测试比较性能
 
 
package com.zxw.jucproject.module.forkjoin;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

public class MyTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        test1();
        test2();
        test3();
       // test4();
    }

    //普通方法计算
    private static void test3() {

        Long sum = 0L;
        Long start = System.currentTimeMillis();
        //1_0000_0000是语法糖，便于识别
        for (Long i = 0L; i <= 1_0000_0000L;i++){
            sum+=i;
        }
        Long end = System.currentTimeMillis();
        System.out.println("耗时--->"+(end-start)+",结果--->"+sum);
    }

    //forkjoin递归
    private static void test2() throws ExecutionException, InterruptedException {

        Long start = System.currentTimeMillis();

        ForkJoinDemo test = new ForkJoinDemo(0L, 1_0000_0000L);
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask submit = forkJoinPool.submit(test);
        Long sum = submit.get();
        Long end = System.currentTimeMillis();
        System.out.println("耗时--->"+(end-start)+",结果--->"+sum);
    }

    //流计算
    private static void test1() {

        Long start = System.currentTimeMillis();
        long sum = LongStream.rangeClosed(0L, 1_0000_0000L).sum();
        Long end = System.currentTimeMillis();
        System.out.println("耗时--->"+(end-start)+",结果--->"+sum);

    }

    // forkjoin  6000
    private static void test4() throws ExecutionException, InterruptedException {

        long start = System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinWork forkJoinWork = new ForkJoinWork(0L, 1_0000_0000L);
        ForkJoinTask submit = forkJoinPool.submit(forkJoinWork);
        Long sum = submit.get();

        long end = System.currentTimeMillis();

        System.out.println("times:"+(end-start)+" r=>"+sum);
    }
}


 
 
14、异步回调
 
 
 
  
前端有异步请求(ajax)，两步走：1、异步请求方法、2、返回方法值
 
 
 
 
那为什么会有异步回调的需求呢？
 
 
 
  
 
   
 
    JUC并发编程引导学习（超长篇）_第2张图片 
   
 
  
 
  

    image-20200308151913619.png 
  
 
 
 
 
异步回调跟多线程类似，就是多开一个线程执行任务，但是有独特功能
 
 
package com.zxw.jucproject.module.future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class CompletableFutureDemo {


    public static void main(String[] args) throws ExecutionException, InterruptedException {

        CompletableFuture completableFuture = new CompletableFuture();

//        //没有回调结果的
//        CompletableFuture voidCompletableFuture = CompletableFuture.runAsync(() -> {
//
//            try {
//                TimeUnit.SECONDS.sleep(2);
//                System.out.println(Thread.currentThread().getName() + "没有返回值");
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        });
//        System.out.println("证明上面任务是异步执行的!");
//        //注意get()方法是获取异步任务结束后的结果，它会等待异步任务执行完毕
//        System.out.println(voidCompletableFuture.get());

        //有回调结果的,且没有异常抛出
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            return 12;
        });
        //当不知道参数是做什么时，把它打印出来就完事
        //当编译完成时
        System.out.println(future.whenComplete((u, v) -> {
            System.out.println("u:------------>" + u);      //u=12返回结果
            System.out.println("v:------------>" + v);      //v=null
        }).exceptionally((e) -> {
            System.out.println(e.getMessage());
            return 500;
        }).get());      //12

        System.out.println("-------------------------天马行空分割线-------------------");
        //有回调结果的,并且有异常抛出
        CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            int a = 10/0;
            return 12;
        });
        //当不知道参数是做什么时，把它打印出来就完事
        //当编译完成时
        System.out.println(future2.whenComplete((u, v) -> {
            System.out.println("u:------------>" + u);      //u=null
            System.out.println("v:------------>" + v);      //v=java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
        }).exceptionally((e) -> {
            System.out.println(e.getMessage());
            return 500;
        }).get());  //500


    }
}


 
 
15、常用辅助类
 
 
1、CountDownLatch
 
 
package com.zxw.jucproject.module.utils;

import java.util.concurrent.CountDownLatch;

/**
 *CountDownLotch允许一个线程或多个线程等待直到其他线程完成的辅助工具
 * 需要注意这是一次性的现象-计数无法重置
 * 实际场景很多：
 *  我们使用多线程调用三方数据源，并且需要取到所有的数据后才进行其它操作。所有之后的线程都需要等待获取数据这个多线程执行完毕
 *
 */
public class CountDownLatchDemo {

    public static void main(String[] args) throws InterruptedException {

        CountDownLatch countDownLatch = new CountDownLatch(3);

        for (int i =0; i < 3; i++){
            final int tmp = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName());
                countDownLatch.countDown();//只要执行完一个线程，就减1
            },String.valueOf(tmp)).start();
        }
        //只有CountDownLatch设定的所有线程执行完毕才会自动解锁，不然一直阻塞
        countDownLatch.await();
        //该线程得等到上述线程执行完毕后才能执行
        System.out.println(Thread.currentThread().getName());
    }
}


 
 
2、CyclicBarrier
 
 
package com.zxw.jucproject.module.utils;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * 允许一组线程全部等待彼此达到共同屏障点的同步辅助。
 * 循环阻塞在涉及固定大小的线程方的程序中很有用，这些线程必须偶尔等待彼此。
 * 屏障被称为循环 ，因为它可以在等待的线程被释放之后重新使用。
 */
public class CyclicBarrierDemo {

    public static void main(String[] args) {

        //当给定数量的线程（线程）等待时，它将跳闸，当屏障跳闸时执行给定的屏障动作，由最后一个进入屏障的线程执行。
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println(Thread.currentThread().getName()+"所有线程都执行完毕了我再执行");
        });

        for (int i = 0; i < 7; i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName());
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}


 
 
3、semaphore
 
 
 
  
主要用在两种地方：多线程共享资源互斥！并发线程的控制！
 
 
 
 
package com.zxw.jucproject.module.utils;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;


/**
 *  计数信号量
 *  作用：固定线程数
 *  实际场景：
 *  总共有三个车位，7辆车进来如何停
 */
public class SemaphoreDemo {

    public static void main(String[] args) {

        //模拟三个车位
        Semaphore semaphore = new Semaphore(3);

        //模拟7辆车
        for(int i = 0; i < 7;i++){
            final int tmp = i;
            new Thread(()->{
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"抢到了车位");
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println(Thread.currentThread().getName()+"离开了车位");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }
            },String.valueOf(tmp)).start();
        }
    }
}


 
 
16、 JMM(Java内存模型)
 
 
 
  
JAVA虚拟机中规范了Java内存模型（java memory model JMM），用来屏蔽掉各种硬件以及不同操作系统内存访问的差异，保证Java在不同平台能达到并发一致性。
 
 
 
 
JVM内存模型是JVM内存分区，JMM内存模型是一种虚拟机规范
 
 
Java内存模型和硬件内存架构联系图：
 
 
 
  
 
   
 
    JUC并发编程引导学习（超长篇）_第3张图片 
   
 
  
 
  

    image-20200314085554621.png 
  
 
 
 
 
从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：
 
 
     
  
  • 线程之间的共享变量存储在主内存（Main Memory）中
    •  
  
  • 每个线程都有一个私有的本地内存（Local Memory），本地内存是JMM的一个抽象概念，并不真实存在，它涵盖了缓存、写缓冲区、寄存器以及其他的硬件和编译器优化。本地内存中存储了该线程以读/写共享变量的拷贝副本。
    •  
  
  • 从更低的层次来说，主内存就是硬件的内存，而为了获取更好的运行速度，虚拟机及硬件系统可能会让工作内存优先存储于寄存器和高速缓存中。
    •  
  
  • Java内存模型中的线程的工作内存（working memory）是cpu的寄存器和高速缓存的抽象描述。而JVM的静态内存储模型（JVM内存模型）只是一种对内存的物理划分而已，它只局限在内存，而且只局限在JVM的内存。
    •  
 
 
 
关于主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步到主内存之间的实现细节，Java内存模型定义了以下八种操作来完成：
 
 
     
  
  •  lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态。
    •  
  
  •  unlock（解锁）：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
    •  
  
  •  read（读取）：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用
    •  
  
  •  load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。
    •  
  
  •  use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
    •  
  
  •  assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
    •  
  
  •  store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。
    •  
  
  •  write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。
    •  
 
 
 
Java内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：
 
 
     
  
  • 如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作， 如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。但Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。
    •  
  
  • 不允许read和load、store和write操作之一单独出现
    •  
  
  • 不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。
    •  
  
  • 不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。
    •  
  
  • 一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。
    •  
  
  • 一个变量在同一时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁。lock和unlock必须成对出现
    •  
  
  • 如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值
    •  
  
  • 如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。
    •  
  
  • 对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）。
    •  
 
 
 
多线程读同步与可见性
 
 
可见性（共享对象可见性）：线程对共享变量修改的可见性。当一个线程修改了共享变量的值，其他线程能够立刻得知这个修改
 
 
线程缓存导致的可见性问题：
 
 
如果两个或者更多的线程在没有正确的使用volatile声明或者同步的情况下共享一个对象，一个线程更新这个共享对象可能对其它线程来说是不可见的：共享对象被初始化在主存中。跑在CPU上的一个线程将这个共享对象读到CPU缓存中，然后修改了这个对象。只要CPU缓存没有被刷新会主存，对象修改后的版本对跑在其它CPU上的线程都是不可见的。这种方式可能导致每个线程拥有这个共享对象的私有拷贝，每个拷贝停留在不同的CPU缓存中。
 
 
下图示意了这种情形。跑在左边CPU的线程拷贝这个共享对象到它的CPU缓存中，然后将count变量的值修改为2。这个修改对跑在右边CPU上的其它线程是不可见的，因为修改后的count的值还没有被刷新回主存中去。
 
 
 
  
 
   
 
    JUC并发编程引导学习（超长篇）_第4张图片 
   
 
  
 
  

    img 
  
 
 
 
 
解决这个内存可见性问题你可以使用：
 
 
     
  
  • Java中的volatile关键字：volatile关键字可以保证直接从主存中读取一个变量，如果这个变量被修改后，总是会被写回到主存中去。Java内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值这种依赖主内存作为传递媒介的方式来实现可见性的，无论是普通变量还是volatile变量都是如此，普通变量与volatile变量的区别是：volatile的特殊规则保证了新值能立即同步到主内存，以及每个线程在每次使用volatile变量前都立即从主内存刷新。因此我们可以说volatile保证了多线程操作时变量的可见性，而普通变量则不能保证这一点。
    •  
  
  • Java中的synchronized关键字：同步快的可见性是由“如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值”、“对一个变量执行unlock操作之前，必须先把此变量同步回主内存中（执行store和write操作）”这两条规则获得的。
    •  
  
  • Java中的final关键字：final关键字的可见性是指，被final修饰的字段在构造器中一旦被初始化完成，并且构造器没有把“this”的引用传递出去（this引用逃逸是一件很危险的事情，其他线程有可能通过这个引用访问到“初始化了一半”的对象），那么在其他线程就能看见final字段的值（无须同步）
    •  
 
 
 
17、Volatile
 
 
 
  
谈谈你对volatile的理解
 
 
 
 
1、保证内存可见性（保证每个线程在读取主内存中的变量都是最新的，即这个变量一旦被修改后，都会在其他线程读取之前同步到主内存中）
 
 
2、不保证原子性
 
 
3、禁止指令重排
 
 
package com.zxw.jucproject.module.jmm;

import java.util.concurrent.TimeUnit;

/**
 * volatile特点：
 * 1、保证内存可见性
 * 2、不保证原子性
 * 3、禁止指令重排
 * 
 * 该例子证明volatile可以保证内存可见性
 */
public class VolatileDemo {

    private volatile static int num = 0;
    
    public static void main(String[] args) throws InterruptedException {

        new Thread(()->{
            while (num == 0){

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

        TimeUnit.SECONDS.sleep(1L);
        //此时确保线程A一直在循环内
        num = 1;
        System.out.println(num);

    }
}


 
 
package com.zxw.jucproject.module.jmm;

/**
 * 该例子证明volatile不能保证原子性
 */
public class VolatileDemo2 {

    private volatile static int num = 0;

    public static void add(){
        num++;
    }

    public static void main(String[] args) {

//        创建10个线程,若能保证原子性，则结果为1000
        for (int i = 0; i < 10; i++){
            new Thread(()->{
                for (int j = 0; j < 100; j++){
                    add();
                }
            }).start();
        }

        //一个程序运行最少存在两个线程：main线程和gc线程
        if (Thread.activeCount() > 2){
            //yeild线程让步，让其他线程有限执行，自己稍后执行
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+num);
    }

    /**
     * 该结果为main0
     * 原因：因为main线程比A线程早执行，可以在add方法中打印输出
     * @param args
     */
    public static void main01(String[] args){
        
        new Thread(()->add(),"A").start();
        System.out.println(Thread.currentThread().getName()+num);//输出：main0
    }
}

 
 
那么如何才能保证原子性，答：使用锁，synchronize或者lock
 
 
单纯这个例子而言，不能保证原子性的操作根本原因在于num++语法不是原子性的，底层实现是先获取num值，再+1再保存值。那么有没有什么整数类型能保证原子性吗？
 
 
答：查API文档java.util.concurrent.atomic包
 
 
 package com.zxw.jucproject.module.jmm;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * AtomicInteger整型操作保证原子性
 */
public class AtomicIntegerDemo {

    private static AtomicInteger num = new AtomicInteger(0);

    public static  void add(){
        num.addAndGet(1);
    }

    public static void main(String[] args) {

        for (int i = 0; i < 10; i++){
            new Thread(()->{
                for (int j = 0; j < 100; j++){
                    add();
                }
            }).start();
        }

        if (Thread.activeCount() > 2){
            Thread.yield();
        }
        System.out.println(num);
    }

}


 
 
 
  
指令重排: 编译器可以安排程序的语句执行顺序
 
 
 
 
例子：
 
 
int x = 1,y=2;//1
x = x+1;//2
y = y+2;//3
int z = x*y//4
执行顺序可以是：1234、1324

 
 
编译器进行指令重排时会考虑指令数据之间的依赖性，所以在单线程下指令重排一定是安全的
 
 
但是多线程无法保证
 
 
例子：
 
 
int x,y,a,b=0;

//线程A                                                               //线程B
x = a;                                                              y=b;
b = 1;                                                              a=1;



//正确的结果是x=0,y=0
//但若进行指令重排(线程A和线程B指令之间不存在依赖性，所以可以进行指令重排)
//线程A                                                               //线程B
b = 1;                                                              a=1;
x = a;                                                              y=b;
//可能结果就是x=1,y=1

 
 
volatile能禁止指令重排，他能给各个指令提供内存屏障memory barrier，确保指令按顺序执行
 
 
18、单例模式
 
 
单例模式核心思想就是构造方法私有化
 
 
1、恶汉模式
 
 
package com.zxw.jucproject.module.single;

/**
 * 单例模式: 构造方法私有
 * 恶汉式
 */
public class HungrySingleDemo {

    //占用内存空间大，若在类未加载情况下已经加载，浪费内存空间
    private byte[] data = new byte[1024*1024];

    private HungrySingleDemo(){}

    //final,static 类在未加载之前就已经初始化分配内存了，恶汉模式浪费内存
    public final static HungrySingleDemo hungrySingle = new HungrySingleDemo();


    public static  HungrySingleDemo getInstance(){

        return hungrySingle;
    }


}

 
 
2、懒汉模式
 
 
package com.zxw.jucproject.module.single;

/**
 * 单例模式：
 * 懒汉式
 * 在多线程下失效,因为lazySingle = new LazySingleDemo();不是原子性操作
 */
public class LazySingleDemo {

    private String data;

    private LazySingleDemo(){
        System.out.println(Thread.currentThread().getName()+"init");
    }

    private static  LazySingleDemo lazySingle;

    public static LazySingleDemo getInstance(){
        if (lazySingle == null){
            lazySingle = new LazySingleDemo();
        }
        return lazySingle;
    }

    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {
            new Thread(()->{
               LazySingleDemo lazySingleDemo = LazySingleDemo.getInstance();
            },String.valueOf(i)).start();
        }
    }
}


 
 
3、DCL懒汉式
 
 
DCL:double check lock,双重检查锁
 
 
package com.zxw.jucproject.module.single;

/**
 * 单例模式
 * DCL懒汉式
 * DCL：double check lock 双重检查锁
 *
 */
public class DclLazySingleDemo {

    private String data;

    private DclLazySingleDemo(){
        System.out.println(Thread.currentThread().getName()+"init");
    }

    private static  DclLazySingleDemo dclLazySingle;

    public static DclLazySingleDemo getInstance(){
        if (dclLazySingle == null) {
            synchronized (DclLazySingleDemo.class) {
                if (dclLazySingle == null) {
                    dclLazySingle = new DclLazySingleDemo();
                }
            }
        }
        return dclLazySingle;
    }

    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                DclLazySingleDemo dclLazySingle = DclLazySingleDemo.getInstance();
            },String.valueOf(i)).start();
        }
    }

}

 
 
4、反射破坏单例
 
 
package com.zxw.jucproject.module.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * 单例模式
 * DCL懒汉式
 * DCL：double check lock 双重检查锁
 *
 */
public class DclLazySingleDemo {

    private String data;

    private DclLazySingleDemo(){
        System.out.println(Thread.currentThread().getName()+"init");
    }

    private static  DclLazySingleDemo dclLazySingle;

    public static DclLazySingleDemo getInstance(){
        if (dclLazySingle == null) {
            synchronized (DclLazySingleDemo.class) {
                if (dclLazySingle == null) {
                    dclLazySingle = new DclLazySingleDemo();
                }
            }
        }
        return dclLazySingle;
    }

    /**
     * 反射可破坏DCL懒汉式单例模式
     * @param args
     * @throws NoSuchMethodException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     * @throws InstantiationException
     */
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        for (int  i = 0; i < 5; i++) {
            new Thread(()->{
                Constructor declaredConstructor = null;
                try {
                    declaredConstructor = DclLazySingleDemo.class.getDeclaredConstructor();
                    DclLazySingleDemo dclLazySingleDemo1 = declaredConstructor.newInstance();
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                }
            }).start();

        }
    }

}


 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(JUC并发编程引导学习（超长篇）)

        

            

                
    
                    
  • 情绪觉察日记第37天
                        露露_e800

                        
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 铭刻于星（四十二）
                        随风至

                        
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    
                    
    • 
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）
                        研学随笔
arcgis经验分享
                        
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • 回溯 Leetcode 332 重新安排行程
                        mmaerd
Leetcode刷题学习记录leetcode算法职场和发展
                        
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
    
                    
    • 
                    
  • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    
                    
    • 
                    
  • 2019-12-22-22:30
                        涓涓1016

                        
    今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
    
                    
    • 
                    
  • 将cmd中命令输出保存为txt文本文件
                        落难Coder
Windowscmdwindow
                        
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
    
                    
    • 
                    
  • 四章-32-点要素的聚合
                        彩云飘过

                        
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    
                    
    • 
                    
  • GitHub上克隆项目
                        bigbig猩猩
github
                        
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
    
                    
    • 
                    
  • 人工智能时代，程序员如何保持核心竞争力？
                        jmoych
人工智能
                        
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
    
                    
    • 
                    
  • 走向以教育叙事为载体的教育叙事研究
                        666小飞鱼

                        
    今天我读了吴松超老师的《给教师的68条建写作建议》中的第23条《如何通过教育叙事走向研究》，吴老师在文中与我们分享了一个德育案例，这是一个反面的案例，意在告知我们在处理问题时，不能就考虑的点太窄，思考要全面。走向教育叙事研究，教师要有敏锐的“感知力”，这个感知力来自于背后专业知识的支撑，思维能力以及广阔的视野和见识等。所以对于同一件事处理方法不同，这个就是教师背后“敏锐力”的不同造成的，也就是说是
    
                    
    • 
                    
  • 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的运行
    
                    
    • 
                    
  • 阶段总结反思
                        轻争

                        
    马上就要进入10月份了，今天做一下前段时间的总结和反思。前段时间，日更、英语、健身、护肤坚持的比较好。阅读、书法坚持的不好。1.中间被迫停更半个多月，其余时间一直在坚持日更挑战。偶尔也有不想写的时候，就做一下摘抄。因为阅读（输入）没跟上来，所以写作（输出）质量有待进一步加强。2.英语做到了一周至少学习5天，每次不少于30分钟，但是小班课没有跟上更新速度，下一步要争取利用零碎时间补听小班课。3.减肥
    
                    
    • 
                    
  • 第六集如何安装CentOS7.0，3分钟学会centos7安装教程
                        date分享

                        
    从光盘引导系统按回车键继续进入引导程序安装界面，选择语言这里选择简体中文版点击继续选择桌面安装下面给系统分区选择磁盘，点击完成选择基本分区，点击加号swap分区,大小填内存的两倍在选择根分区，使用所有可用的磁盘空间选择文件系统ext4点击完成，点击开始安装设置root密码，点击完成设置普通用户和密码，点击完成整个过程持续八分钟左右根据个人配置不同，时间长短不同好，现在点击重启系统进入重启状态点击本
    
                    
    • 
                    
  • ARM驱动学习之基础小知识
                        JT灬新一
ARM嵌入式arm开发学习
                        
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    
                    
    • 
                    
  • ARM驱动学习之5 LEDS驱动
                        JT灬新一
嵌入式C底层arm开发学习单片机
                        
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
    
                    
    • 
                    
  • ARM驱动学习之4小结
                        JT灬新一
嵌入式C++arm开发学习linux
                        
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
    
                    
    • 
                    
  • 展现思维导图魅力，不断挖掘人生宝藏
                        思维导图讲师Mandy

                        
    第13期最强思维导图训练营已经结束一周了，但是我依旧是感觉所有学员还在努力的学习，这些学员中有教师、学生、白领、公务员、宝妈等等，只要你努力，只要你想改变自己，任何行业，任何岗位都可以参与进来，28天足以让你见成效，在这28天中，我们的学员不仅仅是收获了一枚毕业证，最重要的是让自己的思维方式得到升级，今天的你为自己投资，明天的你就会感谢你今天的付出，我们来听一听来自13期最强思维导图训练营优秀学员
    
                    
    • 
                    
  • 2019-3-23晨间日记
                        红红火火小耳朵

                        
    今天是什么日子起床：7点40就寝：23点半天气：有太阳，不过一会儿出来一会儿进去特别清爽的凉意，还蛮舒服的心情：小激动要给女朋友过生日啦纪念日：田田女士过生日任务清单昨日完成的任务，最重要的三件事：1.英语一对一2.运动计划3.认真护肤习惯养成：调整状态周目标·完成进度英语七天打卡（5/7）轻课阅读（87/180）音标课（25/30）读书（福尔摩斯一章）学习·信息·阅读#英语课#Cookingte
    
                    
    • 
                    
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面
                        一个射手座的程序媛
程序员华为od面试职场和发展
                        
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
    
                    
    • 
                    
  • 教育
                        用心灵温暖心灵

                        
    @陈春丽长期学习班冯倩。今天一早就听到说高职合并，取消中专教育的教育信息。感觉是虽然知道，再听还是吓一跳。国家重视职业教育为何还要取消中专技术学校的教育？再听高中就要进行技术教育了，一部分人学习好继续努力学习考大学，一部分人在高中就可以进行职业教育接受职业教育了还要中专技术教育学校干什么呢！a有些职业教育学校转型升级快，不是孩子上完给找工作，而是学校帮孩子创业，我觉得是不错的方向！新闻新你得实时更
    
                    
    • 
                    
  • 数字里的世界17期：2021年全球10大顶级数据中心，中国移动榜首
                        张三叨

                        
    你知道吗？2016年，全球的数据中心共计用电4160亿千瓦时，比整个英国的发电量还多40％！前言每天，我们都会创造超过250万TB的数据。并且随着物联网（IOT）的不断普及，这一数据将持续增长。如此庞大的数据被存储在被称为“数据中心”的专用设施中。虽然最早的数据中心建于20世纪40年代，但直到1997-2000年的互联网泡沫期间才逐渐成为主流。当前人类的技术，比如人工智能和机器学习，已经将我们推向
    
                    
    • 
                    
  • 学习“论语”-第59天
                        春峰轩

                        
    12.14子张问政。子曰：“居之无倦，行之以忠。”子张问为政之道。孔子说：“在位尽职不懈怠，执行政令要忠诚。”12.15子曰：“博学于文，约之以礼，亦可以弗畔矣夫！”孔子说：“君子广泛地学习文献，并且用礼节约束自己，也就不会离经叛道了。”12.16子曰：“君子成人之美，不成人之恶。小人反是。”孔子说：“君子成全别人的好事，而不助长别人的坏处。小人则与此相反行事。”知识点:“成人之美，不成人之恶”贯
    
                    
    • 
                    
  • nosql数据库技术与应用知识点
                        皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
                        
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
    
                    
    • 
                                
  • java观察者模式
                                    3213213333332132
java设计模式游戏观察者模式
                                    
    观察者模式——顾名思义，就是一个对象观察另一个对象，当被观察的对象发生变化时，观察者也会跟着变化。 
 
在日常中，我们配java环境变量时，设置一个JAVAHOME变量,这就是被观察者，使用了JAVAHOME变量的对象都是观察者，一旦JAVAHOME的路径改动，其他的也会跟着改动。 
 
这样的例子很多，我想用小时候玩的老鹰捉小鸡游戏来简单的描绘观察者模式。 
 
老鹰会变成观察者，母鸡和小鸡是
    
                                
    • 
                                
  • TFS RESTful API 模拟上传测试
                                    ronin47

                                    
           TFS RESTful API 模拟上传测试。 
　　 
细节参看这里：https://github.com/alibaba/nginx-tfs/blob/master/TFS_RESTful_API.markdown 
模拟POST上传一个图片： 
curl --data-binary @/opt/tfs.png http
    
                                
    • 
                                
  • PHP常用设计模式单例, 工厂, 观察者, 责任链, 装饰, 策略,适配,桥接模式
                                    dcj3sjt126com
设计模式PHP
                                    
    // 多态, 在JAVA中是这样用的, 其实在PHP当中可以自然消除, 因为参数是动态的, 你传什么过来都可以, 不限制类型, 直接调用类的方法
abstract class Tiger {
    public abstract function climb();
}

class XTiger extends Tiger {
    public function  climb()
    
                                
    • 
                                
  • hibernate
                                    171815164
Hibernate
                                    
    main,save 
 
Configuration conf =new Configuration().configure();
SessionFactory sf=conf.buildSessionFactory();
Session sess=sf.openSession();
Transaction tx=sess.beginTransaction();

News a=new 
    
                                
    • 
                                
  • Ant实例分析
                                    g21121
ant
                                    
            下面是一个Ant构建文件的实例，通过这个实例我们可以很清楚的理顺构建一个项目的顺序及依赖关系，从而编写出更加合理的构建文件。 
  
        下面是build.xml的代码： 
<?xml version="1
    
                                
    • 
                                
  • [简单]工作记录_接口返回405原因
                                    53873039oycg
工作
                                    
             最近调接口时候一直报错，错误信息是: 
      
responseCode:405
responseMsg:Method Not Allowed 
       接口请求方式Post. 
    
                                
    • 
                                
  • 关于java.lang.ClassNotFoundException 和 java.lang.NoClassDefFoundError 的区别
                                    程序员是怎么炼成的

                                    
      
 真正完成类的加载工作是通过调用 defineClass来实现的； 
 而启动类的加载过程是通过调用 loadClass来实现的； 
 就是类加载器分为加载和定义 
   
 protected Class<?> findClass(String name) throws ClassNotFoundExcept
    
                                
    • 
                                
  • JDBC学习笔记-JDBC详细的操作流程
                                    aijuans
jdbc
                                    
    所有的JDBC应用程序都具有下面的基本流程：　　1、加载数据库驱动并建立到数据库的连接。　　2、执行SQL语句。　　3、处理结果。　　4、从数据库断开连接释放资源。 
下面我们就来仔细看一看每一个步骤： 
其实按照上面所说每个阶段都可得单独拿出来写成一个独立的类方法文件。共别的应用来调用。 
1、加载数据库驱动并建立到数据库的连接： 
     Html代码    
 
 St
    
                                
    • 
                                
  • rome创建rss
                                    antonyup_2006
tomcatcmsxmlstrutsOpera
                                    
    引用   
1.RSS标准 
 
RSS标准比较混乱，主要有以下3个系列 
 
 RSS 0.9x / 2.0 : RSS技术诞生于1999年的网景公司(Netscape)，其发布了一个0.9版本的规范。2001年，RSS技术标准的发展工作被Userland Software公司的戴夫 温那(Dave Winer)所接手。陆续发布了0.9x的系列版本。当W3C小组发布RSS 1.0后，Dave W
    
                                
    • 
                                
  • html表格和表单基础
                                    百合不是茶
html表格表单meta锚点
                                    
    第一次用html来写东西,感觉压力山大,每次看见别人发的都是比较牛逼的 再看看自己什么都还不会, 
  
html是一种标记语言,其实很简单都是固定的格式 
  
_----------------------------------------表格和表单 
表格是html的重要组成部分,表格用在body里面的 
主要用法如下; 
<table>

     &
    
                                
    • 
                                
  • ibatis如何传入完整的sql语句
                                    bijian1013
javasqlibatis
                                    
            ibatis如何传入完整的sql语句？进一步说，String str ="select * from test_table"，我想把str传入ibatis中执行，是传递整条sql语句。 
        解决办法： 
<
    
                                
    • 
                                
  • 精通Oracle10编程SQL(14)开发动态SQL
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *开发动态SQL
 */
--使用EXECUTE IMMEDIATE处理DDL操作
CREATE OR REPLACE PROCEDURE drop_table(table_name varchar2)
is
   sql_statement varchar2(100);
begin
   sql_statement:='DROP TABLE '||table_name;

    
                                
    • 
                                
  • 【Linux命令】Linux工作中常用命令
                                    bit1129
linux命令
                                    
    不断的总结工作中常用的Linux命令 
  
1.查看端口被哪个进程占用 
  
通过这个命令可以得到占用8085端口的进程号，然后通过ps -ef|grep 进程号得到进程的详细信息 
  
netstat -anp | grep 8085 
  
察看进程ID对应的进程占用的端口号 
  
netstat -anp | grep 进程ID 
&
    
                                
    • 
                                
  • 优秀网站和文档收集
                                    白糖_
网站
                                    
    集成 Flex, Spring, Hibernate 构建应用程序 
  
性能测试工具-JMeter 
  
Hmtl5-IOCN网站 
  
Oracle精简版教程网站 
  
鸟哥的linux私房菜 
  
Jetty中文文档 
  
50个jquery必备代码片段 
  
swfobject.js检测flash版本号工具
    
                                
    • 
                                
  • angular.extend
                                    boyitech
AngularJSangular.extendAngularJS API
                                    
    angular.extend   复制src对象中的属性去dst对象中. 支持多个src对象. 如果你不想改变一个对象，你可以把dst设为空对象{}: var object = angular.extend({}, object1, object2). 注意: angular.extend不支持递归复制.    使用方法:   angular.extend(dst, src);    参数:   
    
                                
    • 
                                
  • java-谷歌面试题-设计方便提取中数的数据结构
                                    bylijinnan
java
                                    
    网上找了一下这道题的解答，但都是提供思路，没有提供具体实现。其中使用大小堆这个思路看似简单，但实现起来要考虑很多。 
以下分别用排序数组和大小堆来实现。 
使用大小堆： 
 

import java.util.Arrays;

public class MedianInHeap {
	/**
	 * 题目：设计方便提取中数的数据结构
	 * 设计一个数据结构，其中包含两个函数，1.插
    
                                
    • 
                                
  • ajaxFileUpload 针对 ie jquery 1.7+不能使用问题修复版本
                                    Chen.H
ajaxFileUploadie6ie7ie8ie9
                                    
    jQuery.extend({
	handleError: function( s, xhr, status, e ) 		{
		// If a local callback was specified, fire it
				if ( s.error ) {
					s.error.call( s.context || s, xhr, status, e );
				}


    
                                
    • 
                                
  • [机器人制造原则]机器人的电池和存储器必须可以替换
                                    comsci
制造
                                    
     
 
       机器人的身体随时随地可能被外来力量所破坏,但是如果机器人的存储器和电池可以更换,那么这个机器人的思维和记忆力就可以保存下来,即使身体受到伤害,在把存储器取下来安装到一个新的身体上之后,原有的性格和能力都可以继续维持..... 
 
       另外,如果一
    
                                
    • 
                                
  • Oracle Multitable INSERT 的用法
                                    daizj
oracle
                                    
    转载Oracle笔记-Multitable INSERT 的用法 
 
http://blog.chinaunix.net/uid-8504518-id-3310531.html 
 
一、Insert基础用法 
 
语法： 
 
    Insert Into 表名 (字段1,字段2,字段3...） 
 
    Values (值1,
    
                                
    • 
                                
  • 专访黑客历史学家George Dyson
                                    datamachine
on
                                    
    20世纪最具威力的两项发明——核弹和计算机出自同一时代、同一群年青人。可是，与大名鼎鼎的曼哈顿计划（第二次世界大战中美国原子弹研究计划）相 比，计算机的起源显得默默无闻。出身计算机世家的历史学家George Dyson在其新书《图灵大教堂》（Turing’s Cathedral）中讲述了阿兰·图灵、约翰·冯·诺依曼等一帮子天才小子创造计算机及预见计算机未来
    
                                
    • 
                                
  • 小学6年级英语单词背诵第一课
                                    dcj3sjt126com
englishword
                                    
    always 总是 
rice 水稻，米饭 
before 在...之前 
live 生活，居住 
  
usual 通常的 
early 早的 
begin 开始 
month 月份 
  
year 年 
last 最后的 
east 东方的 
high 高的 
  
far 远的 
window 窗户 
world 世界 
than 比...更 
  
    
                                
    • 
                                
  • 在线IT教育和在线IT高端教育
                                    dcj3sjt126com
教育
                                    
    codecademy 
http://www.codecademy.com   codeschool 
https://www.codeschool.com   teamtreehouse 
http://teamtreehouse.com   lynda 
http://www.lynda.com/   Coursera 
https://www.coursera.
    
                                
    • 
                                
  • Struts2 xml校验框架所定义的校验文件
                                    蕃薯耀
Struts2 xml校验Struts2 xml校验框架Struts2校验
                                    
      
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年7月11日 15:54:59 星期六 
http://fa
    
                                
    • 
                                
  • mac下安装rar和unrar命令
                                    hanqunfeng
mac
                                    
    1.下载：http://www.rarlab.com/download.htm  选择 
RAR 5.21 for Mac OS X   2.解压下载后的文件   tar -zxvf rarosx-5.2.1.tar   3.cd rar   sudo install -c -o $USER unrar /bin #输入当前用户登录密码   sudo install -c -o $USER rar
    
                                
    • 
                                
  • 三种将list转换为map的方法
                                    jackyrong
list
                                    
      在本文中，介绍三种将list转换为map的方法： 
 
1） 传统方法 
 
假设有某个类如下 
   

class Movie {
    
    private Integer rank;
    private String description;
    
    public Movie(Integer rank, String des
    
                                
    • 
                                
  • 年轻程序员需要学习的5大经验
                                    lampcy
工作PHP程序员
                                    
    在过去的7年半时间里，我带过的软件实习生超过一打，也看到过数以百计的学生和毕业生的档案。我发现很多事情他们都需要学习。或许你会说，我说的不就是某种特定的技术、算法、数学，或者其他特定形式的知识吗？没错，这的确是需要学习的，但却并不是最重要的事情。他们需要学习的最重要的东西是“自我规范”。这些规范就是：尽可能地写出最简洁的代码；如果代码后期会因为改动而变得凌乱不堪就得重构；尽量删除没用的代码，并添加
    
                                
    • 
                                
  • 评“女孩遭野蛮引产致终身不育 60万赔偿款1分未得”医腐深入骨髓
                                    nannan408

                                    
    先来看南方网的一则报道： 
 

再正常不过的结婚、生子，对于29岁的郑畅来说，却是一个永远也无法实现的梦想。从2010年到2015年，从24岁到29岁，一张张新旧不一的诊断书记录了她病情的同时，也清晰地记下了她人生的悲哀。

　　粗暴手术让人发寒

　　2010年7月，在酒店做服务员的郑畅发现自己怀孕了，可男朋友却联系不上。在没有和家人商量的情况下，她决定堕胎。

　　12月5日，
    
                                
    • 
                                
  • 使用jQuery为input输入框绑定回车键事件 VS 为a标签绑定click事件
                                    Everyday都不同
jspinput回车键绑定clickenter
                                    
    假设如题所示的事件为同一个，必须先把该js函数抽离出来，该函数定义了监听的处理： 
  
function search() {
	//监听函数略......	
} 
  
为input框绑定回车事件，当用户在文本框中输入搜索关键字时，按回车键，即可触发search(): 
  
//回车绑定
$(".search").keydown(fun
    
                                
    • 
                                
  • EXT学习记录
                                    tntxia
ext
                                    
      
1. 准备 
  
（1） 官网：http://www.sencha.com/ 
  
里面有源代码和API文档下载。 
  
EXT的域名已经从www.extjs.com改成了www.sencha.com ，但extjs这个域名会自动转到sencha上。 
  
（2）帮助文档： 
  
想要查看EXT的官方文档的话，可以去这里h
    
                                
    • 
                                
  • mybatis3的mapper文件报Referenced file contains errors
                                    xingguangsixian
mybatis
                                    
    最近使用mybatis.3.1.0时无意中碰到一个问题： 
The errors below were detected when validating the file "mybatis-3-mapper.dtd" via the file "account-mapper.xml".  In most cases these errors can be d
    
                                
    •