—阿峰—
—阿峰—

JUC并发包学习

1、什么是JUC

java.util工具包、包、分类

业务：普通的线程代码 Thread

Runable：没有返回值、效率相对于Callable相对较低。

2、线程和进程

进程：一个程序。如：QQ.exe。

一个进程往往可以包含多个线程，至少包含一个线程。

JAVA默认有几个线程？2个 mian、GC

线程：开了一个进程Typora，写字，自动保存（单独的一条线程去做自动保存）

对于JAVA而言：Thread、Runable、Callable

JAVA真的可以开启线程吗？ 开不了

public synchronized void start() {
    /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
     */
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    /* Notify the group that this thread is about to be started
     * so that it can be added to the group's list of threads
     * and the group's unstarted count can be decremented. */
    group.add(this);

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}
//本地方法、底层的C++操作，JAVA无法直接操作硬件
private native void start0();

并发、并行

并发编程：并发、并线

并发（多线程操作同一个资源）

  • CPU一核，模拟出来多个线程，

并行（多个人一起行走）

CPU多核，多个线程可以同时执行；线程池去做

package com.study.juc.demo01;

public class Test1 {
    public static void main(String[] args) {
        //获取CPU的核树
        //CPU密集型、IO密集型
       System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质：充分利用CPU资源

线程有几个状态 6个

public enum State {
    //线程新生
    NEW, 

    //运行
    RUNNABLE,

    //阻塞
    BLOCKED,

    //等待
    WAITING,

    //超时等待，过期不候
    TIMED_WAITING,

    //终止
    TERMINATED;
}

wait/sleep 区别

  1. 来自不同的类

    wait=>Object

    sleep=>Thread

  2. 关于锁的释放

    wait会释放锁，sleep睡觉了，抱着锁睡觉，不会释放

  3. 使用的范围是不通的

    wait必须在同步代码块当中

  4. 是否需要捕获异常

    wait不需要捕获异常

    sleep必须要捕获异常

3、Lock（重点）

传统的synchronized

package com.study.juc.demo01;

//基本的卖票例子

/**
 * 真正的多线程开发，公司的开发，要降低耦合性
 * 线程就是一个单独的资源类，没有任何附属的操作
 * 1、属性、方法
 */
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        //并发：多个线程操作同一个资源类
        Ticket ticket = new Ticket();
        //FunctionalInterface 函数式接口   jdk1.8  lambda表达式   (参数)->{方法体}
        new Thread(() -> {
            for (int i = 1; i < 40; i++) {
                ticket.sale();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 1; i < 40; i++) {
                ticket.sale();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 1; i < 40; i++) {
                ticket.sale();
            }
        }, "C").start();

    }
}

//资源类  OOP（面向对象编程）
class Ticket {
    //属性、方法
    private int number = 30;
    //卖票的方式
    //synchronized 本质：队列，锁
    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票,剩余：" + number);
        }
    }
}

Lock

公平锁：十分公平，要先来后到

非公平锁：十分不公平，可以插队

package com.study.juc.demo01;

//基本的卖票例子

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

/**
 * 真正的多线程开发，公司的开发，要降低耦合性
 * 线程就是一个单独的资源类，没有任何附属的操作
 * 1、属性、方法
 */
public class SaleTicketDemo02 {
    public static void main(String[] args) {
        //并发：多个线程操作同一个资源类
        Ticket2 ticket = new Ticket2();
        //FunctionalInterface 函数式接口   jdk1.8  lambda表达式   (参数)->{方法体}
        new Thread(() -> {
            for (int i = 1; i < 40; i++) {
                ticket.sale();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 1; i < 40; i++) {
                ticket.sale();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 1; i < 40; i++) {
                ticket.sale();
            }
        }, "C").start();

    }
}

/**
 * Lock三部曲
 * 1、newReentrantLock()
 * 2、lock.lock();//加锁
 * 3、finally {
 *             lock.unlock();
 *         }    //解锁
 */
class Ticket2 {
    //属性、方法
    private int number = 30;

    Lock lock = new ReentrantLock();

    public void sale() {
        lock.lock();//加锁
        try {
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票,剩余：" + number);
            }
        } catch (Exception e) {
        } finally {
            lock.unlock();
        }
    }
}

synchronized和lock区别

1、synchronized内置的Java关键字，lock是一个Java类

2、synchronized无法判断获取锁的状态，lock可以判断是否获取到了锁

3、synchronized会自动释放锁，lock必须要手动释放锁！如果不释放锁会造成死锁

4、synchronized 线程1（获得锁）、线程2（等待） ；Lock锁就不一定会等待下去，等不到就结束了

5、synchronized可重入锁，不可以中断，非公平；lock可重入锁，可以判断锁，非公平（可以通过参数自己设置）

6、synchronized适合锁少量的代码同步问题，Lock适合锁大量的同步代码

锁是什么，如何判断锁的是谁

4、生产者与消费者问题

面试：单例模式、排序算法、生产者和消费者、死锁

生产者与消费者问题synchronized版

package com.study.juc.producerconsumer;

/**
 * 线程之间的通信问题：生产者与消费组问题   等待唤醒和通知
 * 线程交替执行  AB操作同一个变量   num=0
 * A  num+1
 * B  num-1
 */
public class Test1 {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();

    }
}

//判断等待，通知其他业务
class Data {//数字 资源类
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        if (number != 0) {
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        //通知其他线程，我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        if (number == 0) {
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        //通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

问题存在：两个线程，但是4个线程的时候是有问题的。这个时候是因为if的愿意，在线程当中应该使用while

if判断一次就不走了，而while不停的去循环监视

1643179965310

package com.study.juc.producerconsumer;

/**
 * 线程之间的通信问题：生产者与消费组问题   等待唤醒和通知
 * 线程交替执行  AB操作同一个变量   num=0
 * A  num+1
 * B  num-1
 */
public class Test2 {
    public static void main(String[] args) {
        Data2 data = new Data2();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();
    }
}

//判断等待，通知其他业务
class Data2 {//数字 资源类
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        while (number != 0) {
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        //通知其他线程，我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        while (number == 0) {
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        //通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

JUC的生产者和消费组问题

1643180444768

代码实现

package com.study.juc.producerconsumer;

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

/**
 * 线程之间的通信问题：生产者与消费组问题   等待唤醒和通知
 * 线程交替执行  AB操作同一个变量   num=0
 * A  num+1
 * B  num-1
 */
public class Test3 {
    public static void main(String[] args) {
        Data2 data = new Data2();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();
    }
}

//判断等待，通知其他业务
class Data3 {//数字 资源类
    private int number = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    //condition.await();   //等待
    //condition.signalAll(); //唤醒全部
    //+1
    public void increment() throws InterruptedException {
        lock.lock();
        try {
            while (number != 0) {
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            //通知其他线程，我+1完毕了
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //-1
    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number == 0) {
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            //通知其他线程，我-1完毕了
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

任何一个新的技术，绝对不是仅仅只是覆盖了原先的技术，肯定有优势和补充

Condition精准的唤醒和通知 A执行完B执行，B执行完D执行，有序进行执行

package com.study.juc.producerconsumer;

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

/**
 * A执行完调用B，B执行完调用C，C执行完调用A
 */
public class Test4 {
    public static void main(String[] args) {
        Data4 data4 = new Data4();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data4.printA();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data4.printB();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data4.printC();
            }
        }, "C").start();

    }


}

class Data4 {
    private Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    private int number = 1; //1 A执行，2 B执行，3 C执行

    public void printA() {
        lock.lock();
        try {
            //业务，判断——》执行——》通知
            while (number != 1) {//判断
                //等待
                condition1.await();
            }
            //通知，通知指定的人
            System.out.println(Thread.currentThread().getName() + "=>AAAAAAAAAAA");
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB() {
        lock.lock();
        try {
            while (number != 2) {
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>BBBBBBBBBB");
            number = 3;
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC() {
        lock.lock();
        try {
            while (number != 3) {
                condition3.await();
            }
            number = 1;
            System.out.println(Thread.currentThread().getName() + "=>CCCCCCCCC");
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

5、8锁现象

锁是什么，如何判断锁的是谁

new this具体的一个对象

static class 是唯一一个class模板

可以去git上去看代码

6、集合类不安全

List不安全

package com.study.juc.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

//java.util.ConcurrentModificationException  多线程ArrayList插入数据会报此异常
public class ListTest {
    public static void main(String[] args) {
        //并发下ArrayList不安全的

        /**
         * 解决方案：
         * 1、List list = new Vector<>();
         * 2、List list = Collections.synchronizedList(new ArrayList<>());
         * 3、JUC的解决方案 List list = new CopyOnWriteArrayList<>();
         */

//        List list = new ArrayList<>();
        //CopyOnWrite  写入时复制，  COW：计算机程序设计领域的一种优化策略
        //多个线程调用的时候 List，读取的时候，是固定的，写入的时候是先复制再替换上去
        //在写入的时候，避免覆盖，造成数据问题

        //CopyOnWriteArrayList比Vector厉害在哪里？
        //Vector是synchronized的，有这个的基本效率会低，CopyOnWriteArrayList使用的lock
        List list = new CopyOnWriteArrayList<>();

        for (int i = 1; i <= 10; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }

    }
}

Set

/**
 * 同理可证：java.util.ConcurrentModificationException
 * 1、 Set set = Collections.synchronizedSet(new HashSet<>());
 * 2、 Set set = new CopyOnWriteArraySet<>();
 */
public class SetTest {
    public static void main(String[] args) {
//        Set set = new HashSet<>();
//        Set set = Collections.synchronizedSet(new HashSet<>());
        Set set = new CopyOnWriteArraySet<>();

        for (int i = 0; i < 30; i++) {

            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(set);
            }, String.valueOf(i)).start();
        }
    }
}

HashSet的底层是什么？

public HashSet() {
    map = new HashMap<>();
}
//add  本质就是map,保证键无法重复
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}
	//PRESENT是一个不变的值
private static final Object PRESENT = new Object();

Map不安全

package com.study.juc.unsafe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;


/**
 *java.util.ConcurrentModificationException
 */
public class MapList {

    public static void main(String[] args) {
        /**
         * map是这样用的吗？ 不是？工作当中不用hashmap
         * 默认等价于new HashMap<>(16,0.75)
         */
//        Map map = new HashMap<>();
        Map map= new ConcurrentHashMap<>( );
        for (int i = 0; i < 30; i++) {

            int finalI = i;
            new Thread(() -> {
                map.put(String.valueOf(finalI),UUID.randomUUID().toString().substring(0, 5));
                System.out.println(map);
            }, String.valueOf(i)).start();
        }
    }
}

7、Callable

Callable接口类似于Runable，因为他们都是为其实例可能由另一个线程执行的设计。然而，Runable不返回结果，也不能抛出被检测的异常，Callable可以。

1、可以有返回值

2、可以抛出异常

3、方法不同 runable是run,callable是call

package com.study.juc.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //new Thread(new Runnable()).start();
        //new Thread(new FutureTask()).start();
        //new Thread(new FutureTask(Callable)).start();
        MyThread thread=new MyThread();
        FutureTask futureTask=new FutureTask(thread); //设备类
        new Thread(futureTask,"A").start();
        String o = (String) futureTask.get();//获取Callable的返回结果     这个get方法可能产生阻塞，所以把他放在最后
        //或者使用异步通信来处理
        System.out.println(o);

    }
}

class MyThread implements Callable{

    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    @Override
    public String call() throws Exception {
        //在此中间有可能有耗时操作
        return "hello word";
    }
}

细节：有缓存、结果可能需要等待、会阻塞

8、常用的辅助类

8.1ConutDownLatch（减法计数器）

1643261822743

package com.study.juc.add;


import java.util.concurrent.CountDownLatch;

//计数器
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        //倒计时   总数是：6    必须要执行任务得时候才去使用
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " GO OUT");
                countDownLatch.countDown(); //计数器减一
            }, String.valueOf(i)).start();
        }
        countDownLatch.await();;//等待计数器归0
        System.out.println("关闭");
    }
}

原理：

countDownLatch.countDown(); //数量减1

countDownLatch.await(); //等待计数器归零，然后再向下执行。

每次调用线程countDown()数量减去1，假设计数器变为0，countDownLatch.await()就会被唤醒，继续执行后续操作。

8.2 CyclicBarrier(加法计数器)

1643340866600

package com.study.juc.add;

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

//加法计数器
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        /**
         * 集齐7颗龙珠召唤神龙
         */
        //召唤龙珠得线程
        //如果一直没有达到7个线程，他会一直运行。
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("召唤神龙成功");
        });
        for (int i = 1; i <= 7; i++) {
            int finalI = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " 手机了" + finalI + "颗龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

8.3Semaphore

1643341390255

例子：抢车位！ 6个车一共有3个停车位置

public class SemaphoreDemo {

    public static void main(String[] args) {
        //线程数量：停车位  （一共有3个线程，也就是一共有3个停车位） 限流 （一功能进来3个）
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();//得到
                    System.out.println(Thread.currentThread().getName() + "抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName() + "离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release(); //释放
                }

            }, String.valueOf(i)).start();
        }
    }

原理：

semaphore.acquire() 获得，假设如果已经满了，需要等待，等待被释放为止
semaphore.release() 释放，会将当前的的信号量释放+1，然后唤醒等待的线程！

作用：多个共享资源互斥的使用！并发限流，控制最大的线程数。

9、读写锁

读可以被多个线程同时读，写的时候只能有一个线程去写，提高了程序的性能

package com.study.juc.rw;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 独占锁（写锁） 一次只能被一个线程占有
 * 共享锁（读锁） 多个线程可以同时占有   
 *  ReadWriteLock 会有三种情况
 *  1、读-读   可以同时操作共存
 *  2、读-写   不能同时操作共存
 *  3、写-写   不能同时操作共存
 *
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCacheLock myCache = new MyCacheLock();

        //写入
        for (int i = 1; i <= 5; i++) {
            int temp = i;
            new Thread(() -> {
                myCache.put(temp + "", temp + "");
            }, String.valueOf(i)).start();
        }
        //读取
        for (int i = 1; i <= 5; i++) {
            int temp = i;
            new Thread(() -> {
                myCache.get(temp + "");
            }, String.valueOf(i)).start();
        }
    }
}


//自定义缓存
class MyCacheLock {
    private volatile Map map = new HashMap<>();
    //读写锁，更加细粒度的控制
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    //存  写   写入的时候，只希望同时只有一个线程写
    public void put(String key, Object value) {
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "写入" + key);
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "写入OK ");
        } 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);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName() + "读取OK ");
        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            readWriteLock.readLock().unlock();
        }

    }
}


//自定义缓存
class MyCache {
    private volatile Map map = new HashMap<>();

    //存  写
    public void put(String key, Object value) {
        System.out.println(Thread.currentThread().getName() + "写入" + key);
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + "写入OK ");

    }

    //读  取
    public void get(String key) {
        System.out.println(Thread.currentThread().getName() + "读取" + key);

        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName() + "读取OK ");

    }
}

10、阻塞队列

队列的特点：先进先出 FIFO

写入：如果队列满了，就必须阻塞等待取走后再进行写入

取：如果队列是空的，就必须等待生产才能取

BlockingQueue不是新的东西

1644376582520

什么情况下我们会使用阻塞队列：多线程并发处理，线程池。

如何使用队列：

４组API

方式 抛出异常 不抛出异常，有返回值 阻塞等待 超时等待
添加 add offer() put offer(,,)
移除 remove poll() take poll(,,)
是否为首行 element peek － －

１、抛出异常

２、不抛出异常

３、阻塞等待

４、超时等待

/**
 * 抛出异常
 */
public static void  test1(){
    //队列的大小
    ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
    System.out.println(blockingQueue.add("a"));
    System.out.println(blockingQueue.add("b"));
    System.out.println(blockingQueue.add("c"));
    //添加超过队列大小，抛出此异常java.lang.IllegalStateException: Queue full
   // System.out.println(blockingQueue.add("d"));
    System.out.println("============================");//

    Object element = blockingQueue.element();  //element查看队首元素
    System.out.println(blockingQueue.remove());
    System.out.println(blockingQueue.remove());
    System.out.println(blockingQueue.remove());
    //移除的时候队列当中没有元素还在继续移除，抛出此异常java.util.NoSuchElementException
    System.out.println(blockingQueue.remove());
}

/**
 * 不抛出异常
 */
public static void  test2(){
    //队列的大小
    ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
    System.out.println(blockingQueue.offer("a"));
    System.out.println(blockingQueue.offer("b"));
    System.out.println(blockingQueue.offer("c"));
    // System.out.println(blockingQueue.offer("d"));  //不抛出异常
    Object peek = blockingQueue.peek();//peek查看队首元素
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());
    //
    System.out.println(blockingQueue.poll());   //返回null,不抛出异常
}

/**
 * 等待，阻塞（一直阻塞）
 */
public static void  test3() throws InterruptedException {
    //队列的大小
    ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

    //一直阻塞
     blockingQueue.put("a");
     blockingQueue.put("b");
     blockingQueue.put("c");
     //blockingQueue.put("d");  //队列没有为止，一直阻塞等待，直到有了位置


    System.out.println(blockingQueue.take());
    System.out.println(blockingQueue.take());
    System.out.println(blockingQueue.take());
    System.out.println(blockingQueue.take()); //队列中没有元素后，要是取得情况下，也会一直阻塞到这

}
/**
 * 等待，阻塞（等待超时）
 */
public static void  test4() throws InterruptedException {
    //队列的大小
    ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

    //一直阻塞
    System.out.println(blockingQueue.offer("a", 1, TimeUnit.SECONDS));
    System.out.println(blockingQueue.offer("b", 1, TimeUnit.SECONDS));
    System.out.println(blockingQueue.offer("c", 1, TimeUnit.SECONDS));
  //  System.out.println(blockingQueue.offer("d", 1, TimeUnit.SECONDS));
    // blockingQueue.offer("d",1, TimeUnit.SECONDS);  //队列没有位置，1秒后如果还没有位置，则自动退出
    System.out.println(blockingQueue.poll(1,TimeUnit.SECONDS));
    System.out.println(blockingQueue.poll(1,TimeUnit.SECONDS));
    System.out.println(blockingQueue.poll(1,TimeUnit.SECONDS));
    System.out.println(blockingQueue.poll(1,TimeUnit.SECONDS));
    //System.out.println(blockingQueue.poll(1,TimeUnit.SECONDS)); //队列中没有元素后，1秒后如果还没有元素，则自动退出
}
 
 
 
  
SynchronousQueue 同步队列、没有容量
 
 
 
 
进去一个元素，必须等待取出来后才能再往里面放一个元素，相当于最多只能放一个元素
 
 
/**
 * 同步队列
 * 和其他的BlockingQueue不一样，SynchronousQueue不存储元素
 * put了一个元素，必须从里面先take取出来，否则put不进去值
 */
public class SynchronousQueueDemo {
    public static void main(String[] args) {
        SynchronousQueue synchronousQueue = new SynchronousQueue();//同步队列

        new Thread(() -> {

            try {
                System.out.println(Thread.currentThread().getName() + " put 1");
                synchronousQueue.put(1);
                System.out.println(Thread.currentThread().getName() + " put 2");
                synchronousQueue.put(2);
                System.out.println(Thread.currentThread().getName() + " put 3");
                synchronousQueue.put(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "T1").start();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + " take=>" + synchronousQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + " take=>" + synchronousQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + " take=>" + synchronousQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "T2").start();
    }

}

 
 
11、线程池（重点）
 
 
线程池：三大方法、7大参数、4中拒绝模式
 
 
 
  
线程池的好处
 
 
 
 
     
  
  1.  
    降低资源的消耗
     
    2.  
  
  2.  
    提高响应的速度
     
    3.  
  
  3.  
    方便管理
     
    线程复用、控制并发数、管理线程
     
    4.  
 
 
 
 
  
线程
 
 
 
 
线程池不允许使用Executors,去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的允许规则，规避资源耗尽的风险
 
 
说明：Executors返回的线程池对象的弊端如下：
 
 
1）FixedThreadPool和SingleThreadPool：
 
 
允许的请求队列长度为Integer.MAX_VALUE,可能会堆积大量的请求，从而导致OOM。
 
 
2）CachedThreadPool和ScheduledThreadPool：
 
 
允许的创建线程数量为Integer.MAX_VALUE,可能会创建大量的线程，从而导致OOM。
 
 
 
  
线程的三大方法
 
 
 
 
/**
 * Executors 工具类，三大方法
 * 使用了线程池之后，使用线程池来创建线程
 */
public class Demo1 {
    public static void main(String[] args) {
//        ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
//      ExecutorService threadPool =   Executors.newFixedThreadPool(5);//创建一个固定的线程池的大小
        ExecutorService threadPool = Executors.newCachedThreadPool(); //可伸缩的，遇强则强，遇弱则弱
        try {
            for (int i = 0; i < 100; i++) {
                //使用了线程池之后，使用线程池创建线程
                threadPool.execute(
                        () -> {
                            System.out.println(Thread.currentThread().getName() + "    OK");
                        }
                );
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完 ，线程池结束要关闭
            threadPool.shutdown();
        }
    }
}

 
 
 
  
7大参数
 
 
 
 
源码分析：
 
 
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue()));
}
public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue());
}
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,	//Integer.MAX_VALUE 约等于21亿
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue());
}

//本质都是ThreadPoolExecutor
//ThreadPoolExecutor的源码：
    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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

 
 
 
  
手动创建一个线程池
 
 
 
 
public class Demo2 {
    public static void main(String[] args) {
        LinkedBlockingQueue queue = new LinkedBlockingQueue(3);
        //最大的线程到底如何定义
        //1、CPU密集型     几核，就是几，可以保持CPU的效率最高 （大量的计算）
        //2、IO密集型 判断你程序中十分IO的线程有多少个，最大线程数就设置为多少（涉及到网络、磁盘IO的任务都是IO密集型）
        ExecutorService threadPool = new ThreadPoolExecutor(2,5,3, TimeUnit.SECONDS,queue,Executors.defaultThreadFactory(),new ThreadPoolExecutor.DiscardPolicy());

        try {
            //最大承载Deque和maxPoolSize
            //超过最大线程数RejectedExecutionException
            for (int i = 0; i <=9; i++) {
                //使用了线程池之后，使用线程池创建线程
                threadPool.execute(
                        () -> {
                            System.out.println(Thread.currentThread().getName() + "    OK");
                        }
                );
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完 ，线程池结束要关闭
            threadPool.shutdown();
        }
    }
}

 
 
 
  
4种拒绝策略
 
 
 
 
/**
 * new ThreadPoolExecutor.AbortPolicy()  银行人员满了，可是还有人来，这个时候不处理这个人的，直接抛出异常 拒绝后的异常为：RejectedExecutionException
 * new ThreadPoolExecutor.CallerRunsPolicy()  哪里来的去哪，但是不爆出异常
 * new ThreadPoolExecutor.DiscardOldestPolicy() 队列满了会尝试去跟最早的竞争，不会抛出异常
 *  new ThreadPoolExecutor.DiscardPolicy() 队列满了不会抛出异常
 */

 
 
1644393032485
 
 
12、四大函数式接口（必须掌握）
 
 
新时达的程序员：lambda表达式、链式编程、函数是接口、Stream流式计算
 
 
函数式接口：只有一个方法的接口
 
 
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
//函数是接口：FunctionalInterface 简化编程模型，在新版本的框架底层大量使用
//foreach就是一个函数式接口

 
 
 
  
函数式接口
 
 
 
 
package com.study.juc.function;

import java.util.function.Function;

/**
 * Function 函数型接口，有一个输入参数，有一个输出
 * 只要是函数型接口 可以用Lambda表达式简化
 */
public class Demo1 {
        public static void main(String[] args) {
        //工具类： 输出输入的值
        Function function = new Function() {
            @Override
            public String apply(String  str) {
                return str;
            }
        };
        System.out.println(function.apply("1111"));
    }
    public static void main(String[] args) {
        Function function = (str) -> {
            return str;
        };
        System.out.println(function.apply("ceshi"));
    }
}

 
 
 
  
断定型接口 :有一个输入参数，返回值只能是bool值
 
 
 
 
/**
 * 断定型接口；有一个输入参数，返回值式布尔值
 */
public class Demo2 {
    //        public static void main(String[] args) {
//        Predicate predicate = new Predicate() {
//            @Override
//            public boolean test(String s) {
//                return s.isEmpty();
//            }
//        };
//    }
    public static void main(String[] args) {
        Predicate predicate = s -> { return s.isEmpty();};
    }
}

 
 
 
  
消费型接口
 
 
 
 
/**
 * Consumer  消费型接口，只有输入，没有返回值
 */
public class Demo3 {
    public static void main(String[] args) {
        Consumer consumer = new Consumer() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
    }

    public static void main(String[] args) {
        Consumer consumer=(s -> {System.out.println(s);});
        consumer.accept("测试");
    }
}

 
 
 
  
供给型接口
 
 
 
 
/**
 * Supplier供给型接口
 */
public class Demo4 {
    public static void main(String[] args) {
        Supplier supplier = new Supplier() {
            @Override
            public String get() {
                return "测试";
            }
        };
        System.out.println(supplier.get());
    }
    public static void main(String[] args) {
        Supplier supplier = () -> { return "测试";};
        System.out.println(supplier.get());
    }
}

 
 
13、Stream流式计算
 
 
package com.study.juc.stream;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 题目要求：一分钟完成此题，只能用一行代码实现
 * 现在有5个用户！筛选：
 * 1、ID必须式偶数
 * 2、年龄必须大于23岁
 * 3、用户名转为大写字母
 * 4、用户名字母倒叙排列
 * 5、只能输出一个用户
 */
public class Test1 {

    public static void main(String[] args) {
        User u1 = new User(1, "a", 21);
        User u2 = new User(2, "b", 22);
        User u3 = new User(3, "c", 23);
        User u4 = new User(4, "d", 24);
        User u5 = new User(5, "e", 25);
        User u6 = new User(6, "f", 26);
        List users = Arrays.asList(u1, u2, u3, u4, u5, u6);
        users.stream().filter(w -> w.getId() % 2 == 0)
                .filter(w -> w.getAge() > 23)
                .map(w -> w.getName().toLowerCase())
                .sorted((uu1, uu2) -> uu2.compareTo(uu1))
                .limit(1).forEach(System.out::println);
    }
}

@Data
@AllArgsConstructor
class User {
    private Integer id;
    private String name;
    private Integer age;
}

 
 
14、ForkJoin
 
 
 
  
什么是ForkJoin
 
 
 
 
ForkJoin在JDK1.7,并行执行任务！提高效率，适用于大数据量的时候
 
 
大数据当中：Map Reduce（将大任务拆分为小任务）
 
 
1644457815696
 
 
ForkJoin特点：工作窃取，可以提高效率。A、B两个线程，B线程执行的快，A线程执行的慢，当B线程执行完后会去A线程里面窃取一个任务去执行。
 
 
A、B他就是一个双端队列，也就是两端（头部和尾部）都可以对队列进行操作
 
 
1644458022746
 
 
15、Futrue
 
 
package com.study.juc.future;

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

/**
 * 异步调用
 * AJAX
 * 1、异步执行
 * 2、成功回调
 * 3、失败回调
 */
public class Demo01 {
    //没有返回值的runAsync的异步回调
//    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        CompletableFuture completableFuture=CompletableFuture.runAsync(()->{
//            try {
//                TimeUnit.SECONDS.sleep(2);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName()+"runAsync=>void");
//        });
//        System.out.println("1111111");
//        completableFuture.get();//获取阻塞执行结果
//    }

    //有返回值的异步回调supplyAsync
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture completableFuture=CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
            int o=1/0;
            return  1024;
        });

        completableFuture.whenComplete((t,u)->{
            System.out.println("t=>"+t);  //t代表正常的返回结果
            System.out.println("u=>"+u);  //u代表错误的信息 u=>java.util.concurrent.CompletionException:

        }).exceptionally((e)->{
            System.out.println(e.getMessage());
            return 233;
        }).get();

    }

}

 
 
16、JMM
 
 
 
  
请你谈谈你对volatile的看法
 
 
 
 
Volatile是虚拟机提供轻量级的同步机制
 
 
1、保证可见性
 
 
2、不保证原子性
 
 
3、禁止指令重排
 
 
 
  
什么是JMM？
 
 
 
 
JMM 是Java内存模型，不存在的东西，他就是一个概念，约定。
 
 
关于JMM一些同步的约定：
 
 
1、线程解锁之前，必须把共享变量立刻刷回主内存当中。
 
 
2、线程加锁之前，必须读取主内存中的最新值到线程的本地内存当中
 
 
3、加锁和解锁是同一把锁
 
 
线程：工作内存、主存
 
 
8个操作
 
 
1644479080796
 
 
内存交互操作
 
 
​ 引用于
 
 
　　内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）
 
 
     
  
  •  
   
       
    
    • lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
      •  
    
    • unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
      •  
    
    • read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
      •  
    
    • load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
      •  
    
    • use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令
      •  
    
    • assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中
      •  
    
    • store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用
      •  
    
    • write 　（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中
      •  
   
     
    •  
 
 
 
　　JMM对这八种指令的使用，制定了如下规则：
 
 
     
  
  •  
   
       
    
    • 不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
      •  
    
    • 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
      •  
    
    • 不允许一个线程将没有assign的数据从工作内存同步回主内存
      •  
    
    • 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作
      •  
    
    • 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
      •  
    
    • 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
      •  
    
    • 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
      •  
    
    • 对一个变量进行unlock操作之前，必须把此变量同步回主内存
      •  
   
     
    •  
 
 
 
　　JMM对这八种操作规则和对volatile的一些特殊规则就能确定哪里操作是线程安全，哪些操作是线程不安全的了。但是这些规则实在复杂，很难在实践中直接分析。所以一般我们也不会通过上述规则进行分析。更多的时候，使用java的happen-before规则来进行分析。
 
 
共享内存模型指的是JAVA内存模型，简称JMM，JMM决定一个线程对共享变量的写入时，能对另一个线程可见。共享变量放在主内存中，每个线程都有自己的本地内存，当多个线程同时访问一个数据的时候，可能本地内存没有及时刷新到主内存，所以就会发生线程安全的问题，这个时候就有volatile了
 
 
17、Volatile
 
 
 
  
1、保证可见性
 
 
 
 
//不加volatile程序就会死循环。 没有通知主内存num值已经变为0
//家volatile可以保证可见性
private static volatile int num = 0;

public static void main(String[] args) throws InterruptedException {
    new Thread(() -> {//线程1 对主内存的变化不知道
        while (num==0)
        {
        }
    },"线程一").start();
    TimeUnit.SECONDS.sleep(1);
    num=1;
    System.out.println(num);
}

 
 
 
  
2、不保证原子性
 
 
 
 
原子性：不可分割
 
 
线程A在执行任务的时候，不能被打扰，也不能被分割。要么同时成功，要么同时失败。
 
 
1644481573452
 
 
一般num++这种操作使用原子类去操作。
 
 
package com.study.juc.tvolatile;

import java.util.concurrent.atomic.AtomicInteger;

//不保证原子性
public class VDemo2 {
    //volatile不保证原子性
//    private volatile static int num = 0;
    private volatile static AtomicInteger num = new AtomicInteger(0);

    public  static void add() {
        //num++; //不是原子性操作
        num.getAndIncrement();//+1的操作  CAS锁解决的
    }

    public static void main(String[] args) {
        //理论上num的结果应该是2万
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
        //判断存活的线程数量
        while (Thread.activeCount()>2) //java 有两个线程是默认存在的分别为：main和GC
        {
            Thread.yield();
        }
        System.out.println(num);
    }
}

 
 
这些类的底层都直接和操作系统挂钩，在内存中修改值！Unsafe是一个很特殊的存在。
 
 
 
  
指令重排
 
 
 
 
什么是指令重拍：你写的程序，计算机并不是按照你的那样去执行的。
 
 
处理器在进行指令重排的时候，考虑：数据之间的依赖性
 
 
源代码——>编译器优化进行重排——>指令并行也会重排——>内存系统也会重排——>执行
 
 
 
  
非计算机专业
 
 
 
 
volatile可以避免指令重排：
 
 
内存屏障。CPU指令。作用：
 
 
1、保证特定的操作的执行顺序
 
 
2、可以保证某些变量的内存可见性
 
 
1644483147440
 
 
volatile是可以保持可见性。不能保证原子性，由于内存屏障，可以保证避免指令重排的象限发生。
 
 
18、单例模式
 
 
 
  
饿汉式单例模式
 
 
 
 
/**
 * 饿汉式单列
 */
public class Hungry {

    //可能浪费时间
    private byte[] data1 = new byte[1024 * 1024];
    private byte[] data2 = new byte[1024 * 1024];
    private byte[] data3 = new byte[1024 * 1024];
    private byte[] data4 = new byte[1024 * 1024];

    private Hungry() {
    }

    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance() {
        return HUNGRY;
    }
}

 
 
 
  
懒汉式单列模式
 
 
 
 
package com.study.juc.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

/**
 * 懒汉式
 * 

 * 单线程没有问题
 * public static LazyMan getInstance() {
 * if (LAZY_MAN == null) {
 * LAZY_MAN = new LazyMan();
 * }
 * return LAZY_MAN;
 * }
 *
 *
 * 道高一尺魔高一丈
 */
public class LazyMan {
    private static boolean flag = false;

    public LazyMan() {
        synchronized (LazyMan.class) {   //synchronized只采取这一种方式，对象都用反射进行创建也会出现创建两次。 需要再配合一个变量执行，列如：红绿灯
            if (!flag) {
                flag = true;
            } else {
                throw new RuntimeException("不要试图使用反射来进行破坏");
            }
            System.out.println(Thread.currentThread().getName() + "ok");
        }
    }

    public static volatile LazyMan LAZY_MAN;

    //双重检测懒汉式的 懒汉式单列 DCL懒汉式
    public static LazyMan getInstance() {
        if (LAZY_MAN == null) {
            synchronized (LazyMan.class) {
                if (LAZY_MAN == null) {
                    LAZY_MAN = new LazyMan(); //不是原子性操作
                    /**
                     * 1、分配内存空间
                     * 2、执行构造方法，初始化对象
                     * 3、把这个对象指向这个空间
                     *
                     * 执行顺序有可能是123，也有能为132.
                     * 这个时候多线程的时候就会出现指令重拍， A线程创建完成后把这个对象还没有指向这个空间的时候，锁已经释放。 这个时候下一个线程已经过来了，判断的时候已经判断出
                     * LAZY_MAN还有没有为空。
                     */
                }
            }
        }
        return LAZY_MAN;
    }

    //多线程并发的时候如果没有使用synchronized 就会出现问题，创建多次。
//    public static void main(String[] args) {
//        for (int i = 0; i <= 20; i++) {
//            new Thread(() -> {
//                LazyMan.getInstance();
//            }, String.valueOf(i)).start();
//
//        }
//    }

    //反射可以破坏这种单列    反射不能破坏枚举
    public static void main(String[] args) throws Exception {
        // LazyMan lazyMan = LazyMan.getInstance();
        Constructor declaredConstructor = LazyMan.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);//无视私有的构造器
        Field flag = LazyMan.class.getDeclaredField("flag");
        LazyMan lazyMan1 = declaredConstructor.newInstance();
        flag.set(lazyMan1,false);
        LazyMan lazyMan = declaredConstructor.newInstance();

        System.out.println(lazyMan);
        System.out.println(lazyMan1);
        System.out.println(lazyMan == lazyMan1);
        System.out.println(lazyMan.equals(lazyMan1));

    }
}

 
 
 
  
静态内部类
 
 
 
 
package com.study.juc.single;

/**
 * 静态内部类
 */
public class Holder {

    private Holder(){

    }
    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }
    public static  class InnerClass{

        private static final Holder HOLDER=new Holder();

    }
}

 
 
 
  
单列不安全，因为有反射，所以采取枚举
 
 
 
 
package com.study.juc.single;

//enum 是一个什么？ 本身也是一个class类

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

public enum EnumSingle {
    INSTANCE;

    public EnumSingle getInstance() {
        return INSTANCE;
    }


}

class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance = EnumSingle.INSTANCE;
        Constructor declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle enumSingle = declaredConstructor.newInstance();
        System.out.println(instance);
        System.out.println(enumSingle);// java.lang.IllegalArgumentException: Cannot reflectively create enum objects
    }
}

 
 
枚举类型得最终反编译源码
 
 
1644545487439
 
 
1644545461069
 
 
19、深入了解CAS
 
 
 
  
什么是CAS
 
 
 
 
package com.study.juc.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {
    //CAS compareAndSet :比较并交换。     compareAndSet和getAndIncrement的底层都是调用compareAndSwapInt方法。
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2022);
        //第一参数：期望值，第二个参数：修改后得值
        //public final boolean compareAndSet(int expect, int update)
        //如果我期望得值达到了，那么就更新，否则不更新，CAS是CPU并发得原语也就是CPU的指令
        boolean b = atomicInteger.compareAndSet(2022, 2023);
        System.out.println(b);
        System.out.println(atomicInteger.get());
        boolean b1 = atomicInteger.compareAndSet(2022, 2023);


        System.out.println(b1);
        System.out.println(atomicInteger.get());

        atomicInteger.getAndIncrement();

    }
}

 
 
 
  
Unsafe类
 
 
 
 
1644546523675
 
 
1644547251934
 
 
1644547178089
 
 
CAS：比较当前工作内存中的值和主内存的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环！
 
 
缺点：
 
 
     
  
  1. 循环会耗时
    2.  
  
  2. 一次性只能保证一个共享变量的原子性
    3.  
  
  3. ABA问题
    4.  
 
 
 
 
  
CAS:ABA(狸猫换太子)
 
 
 
 
1644548378075
 
 
[^ ]: A线程要将值1改为2，但是这时候B线程执行的比较快，将值1改为3，又将3改为1. 而A线程不知情，接着直接把1改为2. 这就是所谓的ABA问题
 
 
package com.study.juc.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {
    //CAS compareAndSet :比较并交换。     compareAndSet和getAndIncrement的底层都是调用compareAndSwapInt方法。
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2022);
        //第一参数：期望值，第二个参数：修改后得值
        //public final boolean compareAndSet(int expect, int update)
        //如果我期望得值达到了，那么就更新，否则不更新，CAS是CPU并发得原语也就是CPU的指令
        //============捣乱的线程====================
        System.out.println(atomicInteger.compareAndSet(2022, 2023));
        System.out.println(atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(2023, 2022));
        System.out.println(atomicInteger.get());
        //============期望的线程====================
        System.out.println(atomicInteger.compareAndSet(2022, 8888));
        System.out.println(atomicInteger.get());
    }
}

 
 
20、原子引用
 
 
 
  
解决ABA问题
 
 
 
 
Integer使用了对象缓存机制，默认范围是-128~127，推荐使用静态方法valueOf获取对象的实例，而不是new,因为valueOf使用缓存，而new一定会创建新的对象分配新的内存空间
 
 
1644550643119
 
 
package com.study.juc.cas;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;

public class CASReferenceDemo {

    public static void main(String[] args) {
        //1就是初始版本号
        //AtomicStampedReference注意：如果泛型是包装类，注意引用
        //正常的业务操作泛型当中放入的都是一个对象   如果要是使用大的值比如操纵127的，提前声明变量，在参数当中放入变量
        AtomicStampedReference atomicStampedReference=new AtomicStampedReference<>(1,1);
         new Thread(()->{
             int stamp = atomicStampedReference.getStamp();
             System.out.println("a1=>"+stamp);
             try {
                 TimeUnit.SECONDS.sleep(2);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             System.out.println(atomicStampedReference.compareAndSet(1, 2, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
             System.out.println("a2=>"+atomicStampedReference.getStamp());

             System.out.println(atomicStampedReference.compareAndSet(2, 1, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
             System.out.println("a2=>"+atomicStampedReference.getStamp());

         },"A线程").start();
        //与乐观锁的原理相同
        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();
            System.out.println("b1=>"+stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicStampedReference.compareAndSet(1, 6, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("b2=>"+atomicStampedReference.getStamp());



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

    }
}

 
 
21、各种锁的理解
 
 
1、公平锁、非公平锁
 
 
公平锁：非常公平。不能插队，必须先来后到
 
 
非公平锁：非常不公平。可以插队（默认都是非公平锁）
 
 
public ReentrantLock() {
    sync = new NonfairSync();  //默认是非公平锁
}
public ReentrantLock(boolean fair) {//可通过参数就行控制为：公平锁或非公平锁
    sync = fair ? new FairSync() : new NonfairSync();
}

 
 
2、可重入锁
 
 
可重入锁（递归锁），拿到了第一层的锁，就拿到了里面所以锁都已经拿到
 
 
 
  
synchronized
 
 
 
 
package com.study.juc.lock;

/**
 * synchronized
 */
public class Demo01 {
    public static void main(String[] args) {
        Phone phone=new Phone();

        new Thread(()->{
            phone.sms();
        },"A").start();
        new Thread(()->{
            phone.sms();
        },"B").start();
    }
}

class  Phone
{
    public  synchronized void  sms(){
        System.out.println(Thread.currentThread().getName()+"->sms");
        call();
    }

    public  synchronized void  call(){
        System.out.println(Thread.currentThread().getName()+"->call");

    }
}

 
 
 
  
Lock
 
 
 
 
package com.study.juc.lock;

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

/**
 * synchronized
 */
public class Demo02 {
    public static void main(String[] args) {
        Phone1 phone = new Phone1();

        new Thread(() -> {
            phone.sms();
        }, "A").start();
        new Thread(() -> {
            phone.sms();
        }, "B").start();
    }
}

class Phone1 {
    Lock lock = new ReentrantLock();
    public void sms() {

        lock.lock();  //细节问题：lock.lock();   lock.unlock();//lock锁必须配对，否则会死锁到里面。加几次锁必须解几次锁
        try {
            System.out.println(Thread.currentThread().getName() + "->sms");
            call();
        } catch (Exception e) {
        } finally {
            lock.unlock();
        }

    }

    public void call() {

        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "->call");
        } catch (Exception e) {
        } finally {
            lock.unlock();
        }
    }
}

 
 
3、自旋锁（spinlock）
 
 
不断去尝试，直到成功为止。
 
 
1644557554727
 
 
//自定义自旋锁
package com.study.juc.lock;

import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;

public class SpinLockDemo {

    AtomicReference atomicReference=new AtomicReference();
    //加锁
    public void myLock(){
        Thread thread=Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"==>myLock");
        //自旋锁
        while (!atomicReference.compareAndSet(null,thread)){
        }
    }

    //解锁

    public void myUnLock() {
        Thread thread=Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"==>myUnLock");
        atomicReference.compareAndSet(thread,null);
    }
}


//测试自旋锁
package com.study.juc.lock;

import java.util.concurrent.TimeUnit;

public class TestSpinLock {
    public static void main(String[] args) throws InterruptedException {
//        ReentrantLock reentrantLock = new ReentrantLock();
//        reentrantLock.lock();
//        reentrantLock.unlock();

        //底层使用自旋锁  CAS
        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(() -> {
            spinLockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinLockDemo.myUnLock();
            }
        }, "T1").start();

        TimeUnit.SECONDS.sleep(1);


        new Thread(() -> {
            spinLockDemo.myLock();
            try {
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinLockDemo.myUnLock();
            }
        }, "T2").start();

    }
}


 
 
4、死锁
 
 
 
  
死锁是什么？
 
 
 
 
死锁概念及产生原理
 概念： 多个并发进程因争夺系统资源而产生相互等待的现象。
 原理： 当一组进程中的每个进程都在等待某个事件发生，而只有这组进程中的其他进程才能触发该事件，这就称这组进程发生了死锁。
 本质原因：
 1）、系统资源有限。
 2）、进程推进顺序不合理。
 
 
死锁产生的4个必要条件
 1、互斥： 某种资源一次只允许一个进程访问，即该资源一旦分配给某个进程，其他进程就不能再访问，直到该进程访问结束。
 2、占有且等待： 一个进程本身占有资源（一种或多种），同时还有资源未得到满足，正在等待其他进程释放该资源。
 3、不可抢占： 别人已经占有了某项资源，你不能因为自己也需要该资源，就去把别人的资源抢过来。
 4、循环等待： 存在一个进程链，使得每个进程都占有下一个进程所需的至少一种资源。
 当以上四个条件均满足，必然会造成死锁，发生死锁的进程无法进行下去，它们所持有的资源也无法释放。这样会导致CPU的吞吐量下降。所以死锁情况是会浪费系统资源和影响计算机的使用性能的。那么，解决死锁问题就是相当有必要的了。
 
 
 
  
解决问题
 
 
 
 
1、jps -l定位进程号x
 
 
E:\Study\JUC>jps -l
136256
239120 com.study.juc.lock.DeadLockDemo
225348 org.jetbrains.kotlin.daemon.KotlinCompileDaemon
239060 org.jetbrains.jps.cmdline.Launcher
237640 finalshell.jar
239816 sun.tools.jps.Jps



 
 
2、使用jstack 239120(进程号) 可以找到死锁的问题
 
 
 
 
关于文字中的代码都可以在git上去看到和下载。对于文章中的图片，上传太麻烦了，就不做上传了。
 https://github.com/15201600156/JUC.git
 本文学习是参考B站狂神说学习的。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(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无法轻易替代的软技能？让我们一起探讨程序员
    
                    
    • 
                    
  • 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.减肥
    
                    
    • 
                    
  • 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等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
    
                    
    • 
                    
  • 《Python数据分析实战终极指南》
                        xjt921122
python数据分析开发语言
                        
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
    
                    
    • 
                    
  • 2019-01-19
                        王小康KK

                        
    姓名:王康公司:扬州市方圆建筑工程有限公司2018年3月16日～3月18日上海361期《六项精进》感谢二组学员【日精进打卡第307天】【知～学习】《六项精进》大纲3遍共862遍《大学》通篇3遍共860遍《六项精进》全书40页【经典名句】思想决定行为，行为决定习惯，习惯决定性格，性格决定命运。【行～实践】一、修身：（对自己个人）1、践行六项精进的理念。二、齐家：（对家庭和家人）1、和女朋友视频聊天。
    
                    
    • 
                                
  • 基本数据类型和引用类型的初始值
                                    3213213333332132
java基础
                                    
    package com.array;

/**
 * @Description 测试初始值
 * @author FuJianyong
 * 2015-1-22上午10:31:53
 */
public class ArrayTest {
    
	ArrayTest at;
	String str;
	byte bt;
	short s;
	int i;
	long
    
                                
    • 
                                
  • 摘抄笔记--《编写高质量代码：改善Java程序的151个建议》
                                    白糖_
高质量代码
                                    
            记得3年前刚到公司，同桌同事见我无事可做就借我看《编写高质量代码：改善Java程序的151个建议》这本书，当时看了几页没上心就没研究了。到上个月在公司偶然看到，于是乎又找来看看，我的天，真是非常多的干货，对于我这种静不下心的人真是帮助莫大呀。 
  
        看完整本书，也记了不少笔记
    
                                
    • 
                                
  • 【备忘】Django 常用命令及最佳实践
                                    dongwei_6688
django
                                    
    注意：本文基于 Django 1.8.2 版本 
  
生成数据库迁移脚本（python 脚本） 
python manage.py makemigrations polls 
 说明：polls 是你的应用名字，运行该命令时需要根据你的应用名字进行调整 
  
查看该次迁移需要执行的 SQL 语句（只查看语句，并不应用到数据库上）： 
python manage.p
    
                                
    • 
                                
  • 阶乘算法之一N! 末尾有多少个零
                                    周凡杨
java算法阶乘面试效率
                                    
                                     &n
    
                                
    • 
                                
  • spring注入servlet
                                    g21121
Spring注入
                                    
    传统的配置方法是无法将bean或属性直接注入到servlet中的，配置代理servlet亦比较麻烦，这里其实有比较简单的方法，其实就是在servlet的init()方法中加入要注入的内容： 
ServletContext application = getServletContext();
WebApplicationContext wac = WebApplicationContextUtil
    
                                
    • 
                                
  • Jenkins 命令行操作说明文档
                                    510888780
centos
                                    
     
假设Jenkins的URL为http://22.11.140.38:9080/jenkins/ 
 
 
 
基本的格式为 
 
java 
 
基本的格式为 
 
java -jar jenkins-cli.jar [-s JENKINS_URL] command [options][args] 
 
 
 
 
下面具体介绍各个命令的作用及基本使用方法 
 
 
 
1. &nb
    
                                
    • 
                                
  • UnicodeBlock检测中文用法
                                    布衣凌宇
UnicodeBlock
                                    
    /**  * 判断输入的是汉字  */ public static boolean isChinese(char c) {        Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);    
    
                                
    • 
                                
  • java下实现调用oracle的存储过程和函数
                                    aijuans
javaorale
                                    
      1.创建表：STOCK_PRICES 
   
  2.插入测试数据： 
   
  3.建立一个返回游标：  
PKG_PUB_UTILS 
   4.创建和存储过程：P_GET_PRICE 
  
   5.创建函数： 
   6.JAVA调用存储过程返回结果集 
JDBCoracle10G_INVO
    
                                
    • 
                                
  • Velocity Toolbox
                                    antlove
模板toolboxvelocity
                                    
    velocity.VelocityUtil 
package velocity;

import org.apache.velocity.Template;
import org.apache.velocity.app.Velocity;
import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.c
    
                                
    • 
                                
  • JAVA正则表达式匹配基础
                                    百合不是茶
java正则表达式的匹配
                                    
      
正则表达式;提高程序的性能,简化代码,提高代码的可读性,简化对字符串的操作 
  
正则表达式的用途; 
字符串的匹配

字符串的分割

字符串的查找

字符串的替换
 
  
  
  
正则表达式的验证语法 
    
  [a]    //[]表示这个字符只出现一次  ,[a] 表示a只出现一
    
                                
    • 
                                
  • 是否使用EL表达式的配置
                                    bijian1013
jspweb.xmlELEasyTemplate
                                    
            今天在开发过程中发现一个细节问题，由于前端采用EasyTemplate模板方法实现数据展示，但老是不能正常显示出来。后来发现竟是EL将我的EasyTemplate的${...}解释执行了，导致我的模板不能正常展示后台数据。 
        网
    
                                
    • 
                                
  • 精通Oracle10编程SQL(1-3)PLSQL基础
                                    bijian1013
oracle数据库plsql
                                    
    --只包含执行部分的PL/SQL块
--set serveroutput off
begin
  dbms_output.put_line('Hello,everyone!');
end;


select * from emp;

--包含定义部分和执行部分的PL/SQL块
declare
   v_ename varchar2(5);
begin
   select 
    
                                
    • 
                                
  • 【Nginx三】Nginx作为反向代理服务器
                                    bit1129
nginx
                                    
    Nginx一个常用的功能是作为代理服务器。代理服务器通常完成如下的功能： 
  
 
 接受客户端请求 
 将请求转发给被代理的服务器 
 从被代理的服务器获得响应结果 
 把响应结果返回给客户端 
 实例 
本文把Nginx配置成一个简单的代理服务器 
 
 对于静态的html和图片，直接从Nginx获取 
 对于动态的页面，例如JSP或者Servlet，Nginx则将请求转发给Res
    
                                
    • 
                                
  • Plugin execution not covered by lifecycle configuration: org.apache.maven.plugin
                                    blackproof
maven报错
                                    
    转：http://stackoverflow.com/questions/6352208/how-to-solve-plugin-execution-not-covered-by-lifecycle-configuration-for-sprin 
  
maven报错： 
Plugin execution not covered by lifecycle configuration: 
    
                                
    • 
                                
  • 发布docker程序到marathon
                                    ronin47
docker 发布应用
                                    
    1 发布docker程序到marathon 1.1 搭建私有docker registry 1.1.1 安装docker regisry 
docker pull docker-registry
docker run -t -p 5000:5000 docker-registry
 下载docker镜像并发布到私有registry 
docker pull consol/tomcat-8.0

    
                                
    • 
                                
  • java-57-用两个栈实现队列&&用两个队列实现一个栈
                                    bylijinnan
java
                                    
    
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

	/*
	 * Q 57 用两个栈实现队列
	 */

public class QueueImplementByTwoStacks {

	private Stack<Integer> stack1;
	pr
    
                                
    • 
                                
  • Nginx配置性能优化
                                    cfyme
nginx
                                    
    转载地址：http://blog.csdn.net/xifeijian/article/details/20956605 
  
大多数的Nginx安装指南告诉你如下基础知识——通过apt-get安装，修改这里或那里的几行配置，好了，你已经有了一个Web服务器了。而且，在大多数情况下，一个常规安装的nginx对你的网站来说已经能很好地工作了。然而，如果你真的想挤压出Nginx的性能，你必
    
                                
    • 
                                
  • [JAVA图形图像]JAVA体系需要稳扎稳打,逐步推进图像图形处理技术
                                    comsci
java
                                    
     
 
     对图形图像进行精确处理，需要大量的数学工具，即使是从底层硬件模拟层开始设计，也离不开大量的数学工具包，因为我认为，JAVA语言体系在图形图像处理模块上面的研发工作，需要从开发一些基础的，类似实时数学函数构造器和解析器的软件包入手，而不是急于利用第三方代码工具来实现一个不严格的图形图像处理软件...... 
 
  &nb
    
                                
    • 
                                
  • MonkeyRunner的使用
                                    dai_lm
androidMonkeyRunner
                                    
    要使用MonkeyRunner，就要学习使用Python，哎 
 
先抄一段官方doc里的代码 
作用是启动一个程序（应该是启动程序默认的Activity），然后按MENU键，并截屏 
 

# Imports the monkeyrunner modules used by this program
from com.android.monkeyrunner import MonkeyRun
    
                                
    • 
                                
  • Hadoop-- 海量文件的分布式计算处理方案
                                    datamachine
mapreducehadoop分布式计算
                                    
    csdn的一个关于hadoop的分布式处理方案，存档。 
原帖：http://blog.csdn.net/calvinxiu/article/details/1506112。 
 
    Hadoop 是Google MapReduce的一个Java实现。MapReduce是一种简化的分布式编程模式，让程序自动分布到一个由普通机器组成的超大集群上并发执行。就如同ja
    
                                
    • 
                                
  • 以資料庫驗證登入
                                    dcj3sjt126com
yii
                                    
    以資料庫驗證登入 
由於 Yii 內定的原始框架程式, 採用綁定在UserIdentity.php 的 demo 與 admin 帳號密碼:    public function authenticate()    {        $users=array( &nbs
    
                                
    • 
                                
  • github做webhooks：[2]php版本自动触发更新
                                    dcj3sjt126com
githubgitwebhooks
                                    
    上次已经说过了如何在github控制面板做查看url的返回信息了。这次就到了直接贴钩子代码的时候了。       
工具/原料  
 
   git   
   github   
     
方法/步骤  
 
       在github的setting里面的webhooks里把我们的url地址填进去。   
       钩子更新的代码如下： error_reportin
    
                                
    • 
                                
  • Eos开发常用表达式
                                    蕃薯耀
Eos开发Eos入门Eos开发常用表达式
                                    
    Eos开发常用表达式 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2014年8月18日 15:03:35 星期一 
  
  
&
    
                                
    • 
                                
  • SpringSecurity3.X--SpEL 表达式
                                    hanqunfeng
SpringSecurity
                                    
    使用 Spring 表达式语言配置访问控制，要实现这一功能的直接方式是在<http>配置元素上添加 use-expressions 属性： 
  
<http auto-config="true"  use-expressions="true"> 
这样就会在投票器中自动增加一个投票器：org.springframework
    
                                
    • 
                                
  • Redis vs Memcache
                                    IXHONG
redis
                                    
    1. Redis中，并不是所有的数据都一直存储在内存中的，这是和Memcached相比一个最大的区别。 
2. Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，hash等数据结构的存储。 
3. Redis支持数据的备份，即master-slave模式的数据备份。 
4. Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。 
Red
    
                                
    • 
                                
  • Python - 装饰器使用过程中的误区解读
                                    kvhur
JavaScriptjqueryhtml5css
                                    
    大家都知道装饰器是一个很著名的设计模式，经常被用于AOP(面向切面编程)的场景，较为经典的有插入日志，性能测试，事务处理，Web权限校验， Cache等。 
原文链接：http://www.gbtags.com/gb/share/5563.htm 
Python语言本身提供了装饰器语法（@），典型的装饰器实现如下：     
 
 @function_wrapper 
  de
    
                                
    • 
                                
  • 架构师之mybatis-----update 带case when 针对多种情况更新
                                    nannan408
case when
                                    
    1.前言. 
   如题. 
2. 代码. 
  

	<update id="batchUpdate" parameterType="java.util.List">
			<foreach collection="list" item="list" index=&
    
                                
    • 
                                
  • Algorithm算法视频教程
                                    栏目记者
Algorithm算法
                                    
    课程：Algorithm算法视频教程 
 
百度网盘下载地址： http://pan.baidu.com/s/1qWFjjQW 密码: 2mji 
 
 
程序写的好不好,还得看算法屌不屌！Algorithm算法博大精深。 
 一、课程内容： 
课时1、算法的基本概念 + Sequential search 
课时2、Binary search 
课时3、Hash table 
课时4、Algor
    
                                
    • 
                                
  • C语言算法之冒泡排序
                                    qiufeihu
c算法
                                    
    任意输入10个数字由小到大进行排序。 
代码： 
#include <stdio.h>
int main()
{
	int i,j,t,a[11];        /*定义变量及数组为基本类型*/
	for(i = 1;i < 11;i++){
		scanf("%d",&a[i]);     /*从键盘中输入10个数*/
	}
	for
    
                                
    • 
                                
  • JSP异常处理
                                    wyzuomumu
Webjsp
                                    
    1.在可能发生异常的网页中通过指令将HTTP请求转发给另一个专门处理异常的网页中: 
<%@ page errorPage="errors.jsp"%> 
  
2.在处理异常的网页中做如下声明： 
errors.jsp: 
<%@ page isErrorPage="true"%>，这样设置完后就可以在网页中直接访问exc
    
                                
    •