dogs~xiaofei
dogs~xiaofei

JUC基础笔记（尚硅谷周阳JUC的笔记）

JUC

    • 概述
    • 卖票
    • Lambda表达式
    • 线程间的通信
    • 一道经典的线程按顺序打印
    • 多线程8锁
    • 集合线程不安全
    • 实现多线程方式
    • CountDownLatch
    • CyclicBarrier
    • 读写锁
    • 阻塞队列
    • 线程池
    • strem流式计算
    • 分支合并框架
    • 异步回调
    • JMM
    • 总结

概述

  • juc就是 java.util.concurrent包的首字母
  • 下面又分 并发包、 atomic 和 locks 包
  • 也就是所谓的并发工具类
  • 进程： 是程序的一次执行，拥有独立资源的单位
  • 线程：轻量级进程，共享进程中的内存资源 ，程序调度和分配的基本单位， 更好的使程序并发的执行
  • 并发： 是在程序在宏观上是并行， 实则是交替的执行
  • 并行： 两个程序一起执行，同步执行。
  • 在高内聚低耦合的前端下： 多线程编程的企业级套路 + 模板：
    * 线程 操作（对外暴露的调用方法） 资源类
    * 多线程操作共享资源
    * 先写共享资源类
    * 在写对共享资源的操作
    * 实现Runnable接口的匿名实现
    JUC基础笔记（尚硅谷周阳JUC的笔记）_第1张图片
    JUC基础笔记（尚硅谷周阳JUC的笔记）_第2张图片

卖票

//过去javase的写法
class Ticket{//资源类
    //票
    private int number = 30;

    public synchronized void saleTicket(){
        if (number > 0){
            System.out.println(Thread.currentThread().getName()+"\t卖出第："+(number--)+"\t还剩下："+number);
        }
    }
}
/**
 *题目：三个售票员   卖出   30张票
 * 多线程编程的企业级套路+模板
 * 1.在高内聚低耦合的前提下，线程    操作(对外暴露的调用方法)     资源类
 */
public class SaleTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 40; i++) {
                    ticket.saleTicket();
                }
            }
        },"A").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 40; i++) {
                    ticket.saleTicket();
                }
            }
        },"B").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 40; i++) {
                    ticket.saleTicket();
                }
            }
        },"C").start();
    }
}

JUC基础笔记（尚硅谷周阳JUC的笔记）_第3张图片

//利用lock写法 lock相较于synchronized较为灵活， 而且锁的范围更少， 有点类似于操作系统的信号量
public class CurrentTicket {
    public static void main(String[] args) {

        Ticket ticket = new Ticket();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <= 40; i ++)
                  ticket.saleTicket();
            }
        }, "a").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <= 40; i ++)
                  ticket.saleTicket();
            }
        }, "b").start();

        //写成lamb表达式
        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();
    }
}
class Ticket{
    private int count = 50;
    private Lock lock = new ReentrantLock();
    public void saleTicket(){
        lock.lock();

        try {
            if (count > 0){
                System.out.println(Thread.currentThread().getName() + count);
                count --;
            }
        } finally {
            lock.unlock();
        }

    }
}

Lambda表达式

  • 对于一个接口来说如果只一个没有实现的方法可以直接用lambda表达式替换 （为什么说没有实现， 因为jdk8 接口中可以写默认实现， 以及静态方法）
  • 对于声明式函数接口 的注解@FunctionalInterface
  • 原则 拷贝中括号， 写死右箭头， 落地大括号
//什么意思呢
interface Foo{
      int div ();
}
//我们就可以这么做
Foo f = () -> {写实现;  return 值;};
f.div();即可
// 对于有返回值有参数的
 interface Foo{
      int div (int a, int b);
}
Foo f = (a, b) -> {写实现； return 值};
f.div(1, 2);就可以

线程间的通信

  • 一个进程内， 线程间的协调和调度， 操作共享资源。
  • 不同进程间的通信得利用操作系统中讲的进程通信。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author xiaofei
 * @create 2021-07-28 9:53
 */


/*
 * 题目： 现在两个线程， 可以操作初始值位零的一个变量，
 * 实现一个进程对变量加一， 一个线程对改变量减一
 * 实现交替， 来10轮， 变量初始值为零
 *
 *
 * 1、高内聚低耦合， 线程操作资源类
 * 2、判断/干活/通知
 * 3、多线程交互中， 必须要防止多线程的续集唤醒， 也即 （判断使用while不
 * 能用if）
 * 4、标志位
 * 唤醒的时候还必须在判断
 * */

class AirConditioner {
    private int num = 0;
    private Lock lock = new ReentrantLock();

    public synchronized void add() throws InterruptedException {
          //这种情况会出错的原因是线程被唤醒的时侯就不需要在拍段一次条件了故在面对超过两个线程的时候就出现错误
//        if (num != 0) this.wait();
//        num ++;
//        System.out.println(Thread.currentThread().getName() + " " + num);
//
//        this.notifyAll();
        //第一种解决办法
        while (num != 0) this.wait();
        num ++;
        System.out.println(Thread.currentThread().getName() + " " + num);

        this.notifyAll();

        //第二种解决办法 说到底都是 让其唤醒的时候在经历一次判断 另外这样写可能打出来的结果可能不是40行
        // 因为被唤醒之后就不是去去执行本次的操作而是直接本次操作结束 执行 i++ 了
//        if (num == 0) {
//            num ++;
//            System.out.println(Thread.currentThread().getName() + " " + num);
//            this.notifyAll();
//        }else
//            this.wait();


    }

    public synchronized void sub() throws InterruptedException {

        while (num == 0) this.wait();
        num --;
        System.out.println(Thread.currentThread().getName() + " " + num);
        this.notifyAll();

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

public class ThreadWaitNotifyDemo {

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


        AirConditioner airConditioner = new AirConditioner();
        new Thread(() -> {
            try {
//                for (int i = 0; i < 10; i ++) airConditioner.sub();
                while (true) airConditioner.sub();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "B").start();
        new Thread(() -> {
            try {
//                for (int i = 0; i < 10; i ++) airConditioner.add();
                while (true) airConditioner.sub();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "A").start();

        new Thread(() -> {
            try {
//                for (int i = 0; i < 10; i ++) airConditioner.add();
                while (true) airConditioner.add();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "c").start();



        new Thread(() -> {
            try {
//                for (int i = 0; i < 10; i ++) airConditioner.sub();
                while (true) airConditioner.add();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "d").start();

    }
}
  • 新版的生产者消费者
class AirConditioner {
    private int num = 0;
    private Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    public  void add() throws InterruptedException {
        lock.lock();
        try {
            while (num != 0) condition.await();
            num ++;
            System.out.println(Thread.currentThread().getName() + " " + num);
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    public void sub() throws InterruptedException {

        lock.lock();
        try {
            while (num == 0) condition.await();
            num --;
            System.out.println(Thread.currentThread().getName() + " " + num);
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

一道经典的线程按顺序打印

/*
* 多线程之间按顺序调用， 实现A -> B -> C
* 三个线程启动， 要求如下：
* A 打印5次 B 打印10次， CC打印15次
* 接着
* AA打印5次， BB打印10次， CC打印15次
* 来10轮
*  下订单 -> 减库存 -> 调支付
*
* synchronized 它最大的缺点就是不能精确唤醒某个线程
* lock  它灵活可以多个锁精确唤醒
* 可以让某个锁放开当前线程
* 非常像操作系统的信号量的传参， 当前参数被那个锁给await了那么就只能用这把锁把他唤醒，
* 跟线程同步有关操作系统
* */

class Print{

    private int num = 1;  // 1：A 2：B 3 C
    private Lock lock = new ReentrantLock();
    Condition A = lock.newCondition();    //用来锁A的
    Condition B = lock.newCondition();    // 用来锁B的
    Condition C = lock.newCondition();    //用来锁C的

    public void print(int sign){
        if (sign == 1){
            lock.lock();
            try {
                while (num != 1){
                    A.await();
                }
                for (int i = 0; i < 5; i ++){
                    System.out.println(Thread.currentThread().getName() + " " + i);
                }
                num ++;
                B.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }else if (sign == 2){
            lock.lock();
            try {
                while (num != 2){
                    B.await();
                }
                for (int i = 0; i < 10; i ++){
                    System.out.println(Thread.currentThread().getName() + " " + i);
                }
                num ++;
                C.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }else {
            lock.lock();
            try {
                while (num != 3){
                    C.await();
                }
                for (int i = 0; i < 15; i ++){
                    System.out.println(Thread.currentThread().getName() + " " + i);
                }
                num = (num + 1) % 3;
                A.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}
public class ThreadOrderAccess {

    public static void main(String[] args) {
        Print print = new Print();
        new Thread(
                () -> {
                    for (int i = 0; i < 10; i ++) print.print(1);
                }, "A"
        ).start();
        new Thread(
                () -> {
                    for (int i = 0; i < 10; i ++) print.print(2);
                }, "B"
        ).start();new Thread(
                () -> {
                    for (int i = 0; i < 10; i ++) print.print(3);
                }, "C"
        ).start();

    }
}

多线程8锁

  /*
*
* 题目：多线程8锁
* 1、两个普通的同步方法 先打印邮件还是sms ：邮件
* 2、邮件方法暂停3秒钟， 请问先打印那个： 邮件
* 3、邮件方法暂停3秒钟 新增一个普通方法hello()和发邮件, 先打印邮件还是hello : hello
* 4、两部手机一个发邮件一个发短信   发短信
* 5、两个静态同步方法、同一部手机先打印那个 邮件
* 6、两个静态同步方法  两部手机 ： 邮件
* 7、一个静态同步方法， 一个普通同步方法  同一部手机 ： SMS
* 8、一个静态同步方法， 一个普通同步方法  2部手机 ： SMS
*
* 想两个拿同一个手机 一个想打电话一个想发消息， 同一时间是不是只能有一个人拿到这部手机
* 笔记：
*   一个对象里面如果有多个synchronized. 某个时刻内， 只要有一个线程去调用其中的一个synchronized方法
*   其他线程都只能等待， 换句话说， 某个时刻内， 只能有一个对象去访问同一个资源类中的synchronized方法
*   锁的是当前对象this, 被锁定后， 其他线程都不能进入到当前对象的其他的synchronized方法
*   加个普通方法后和同步锁无关
*   换成两个对象之后， 不是同一把锁了， 故无关
*   都换成静态同步方法的时候 对于静态方法的锁是 本类.class
*
*   静态同步方法于非静态同步方法之间是不会有竞态条件的
*   但是一旦一个静态同步方法获取锁后， 其他的静态方法都必须等待该方法释放锁后才能获取锁
*   总之 对于锁相同的时候同时只能有一个线程访问
*
* */

class Phone{
    public static synchronized void sendEmail() throws InterruptedException {
        Thread.sleep(3000);
        System.out.println("sendEmail");
    }
    public  synchronized void sendSmS(){
        System.out.println("sendSMS");
    }

    public void hello(){
        System.out.println("hello");
    }

}
public class Lock8 {

    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> {
            try {
                phone1.sendEmail();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "A").start();

        new Thread(() -> {
            phone2.sendSmS();
        }, "B").start();

        new Thread(() -> {
            phone1.hello();
        }, "C").start();
    }
}

集合线程不安全

/*
* 笔记：
*   写时复制
*   CopyOnWrite 容器即写时复制的容器， 往一个容器添加元素的时候， 不直接往当前容器的object[]添加元素， 而是先将当前容器Object[]
*   进行复制出一个新的容器object[] newElements， 让后新的容器object[] newElements里添加元素， 添加元素之后，
*   在将原容器的引用指向心的容器 setArray(newElements) 这样做的好处时可以对CopyOnWrite容器进行并发的读，
*   而不需要加锁， 因为当前容器不会添加任何元素， 所以CopyOnWrite容器也是一种读写分离的思想， 读和写不同的容器
*    public boolean add(E e) {
*        final ReentrantLock lock = this.lock;
*       lock.lock();
*        try {
*            Object[] elements = getArray();
*            int len = elements.length;
*            Object[] newElements = Arrays.copyOf(elements, len + 1);
*            newElements[len] = e;
*            setArray(newElements);
*            return true;
*        } finally {
*            lock.unlock();
*        }
*    }
*    HashSet底层就是hashmap add方法add一个值就是hashmap的key, value是写死的Object
*    hashMap 底层是一个Node类型的数组加链表+红黑树， 他是使用的拉链发实现的hash表， 数组长度起始为16 负载因子0.75
*    链表超过8就是变成红黑树。
*
* 题目： 请举例说明集合类是不安全的
* ArrayList hashSet hashmap 是线程不安全的
* vector 是线程安全的  only-one 不在乎性能只在乎 线程安全不安全
* 1、故障现象
* 会出现java.utils.concurrentModificationException
*
* 2、导致原因
*    并发修改异常
* 3、解决方案
*   1、 vector
*   2、 Collections.synchronizedList
*   3、 CopyOnWriteArrayList  多线程用这个
*       写的时候复制一份， 让读跟写分离
*     Object[] newElements = Arrays.copyOf(elements, len + 1);
*     newElements[len] = e;
*     setArray(newElements);
*   4、CurrentHashMap -> hashMap
*   5、LinkedList -> ConcurrentLinkedQueue
*   6、hashSet 他的底层就是HashMap所以
*
* 4、优化建议 （同样的错误， 不出现第二次）
*
* */
public class NotSafeDemo {

    public static void main(String[] args) {

        setNoteSafe();

    }

    public static void MapNotSafe(){
//        Map map = new HashMap<>();
        Map<String, String> map = new ConcurrentHashMap<>();

    }

    public static void setNoteSafe (){
//        Set set = new HashSet<>();
        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 1; i <= 30; i++) {
            new Thread(() ->
            {
                set.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(set);
            }, String.valueOf(i)).start();
        }

    }

    public static void listNotSafe (){
//          List list = new ArrayList();
//        List list = new Vector<>();
//        List list = Collections.synchronizedList(new ArrayList());
        List<Object> list = new CopyOnWriteArrayList<>();
        for (int i = 1; i <= 30; i++) {
            new Thread(() ->
            {
                list.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }

}


实现多线程方式


    

  • 传统2种， jdk5之后有4种
    • 

  • 实现多线程的第三种方式
    • 

  • 第四种是线程池在后面讲
    • 



/*
* 多线程中， 第三种获得多线程的方式
*
* 实现runnable接口和Callable的异同
*  1、落地方法不同一个是run一个叫call'
*  2、callable有异常
*  3、callable 有返回值 泛型是什么就返回什么
*  4、callable 支持泛型
*
* get 要放在最后一行
* */

class MyThread1 implements Runnable{
    @Override
    public void run() {

    }
}

class MyThread2 implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {

        System.out.println("aaaaa");
        Thread.sleep(1000);
        return 1024;
    }
}

public class CallableDemo {

    public static void main(String[] args) {
        // 一个futureTask不管多少个线程调都只会被调用一次
        FutureTask futureTask = new FutureTask(new MyThread2());
        try {
            //以下两个线程只会出现一次调用
            new Thread(futureTask,"A").start();
            new Thread(futureTask,"B").start();
            Object o = futureTask.get();   //尽量放在后面在取， 否者会导致程序堵塞
            System.out.println(o);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}



CountDownLatch


 *
 *  CountDownLatch 主要有两个方法， 当一个或多个线程调用await方法， 这些线程回阻塞
 *  其他线程调用countDown方法会将计数器减一，  调用countDown方法的线程不会阻塞
 *  当计数器变为0的时候， 被await的方法才会唤醒继续执行
 *
 */
public class CountDownLatchDemo {

    // 正确做法 实际上我感觉我还没看源码呢，  这个类似于操作系统的P，V操作实现线程同步
    public static void main(String[] args) throws InterruptedException {

        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i <= 6; i++) {

            new Thread(() ->{
                System.out.println(Thread.currentThread().getName() + "同学离开");
                countDownLatch.countDown();
            }, String.valueOf(i)).start();

        }
        //这个证明唤醒所有
        new Thread(() ->{
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "同学离开");

        }, "test").start();
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName() + "班长走了");

    }

    // 要实现班长要比其他同学先走
    //结果
    /*
    * 1同学离开
        main班长走了
        3同学离开
        2同学离开
        6同学离开
        5同学离开
        4同学离开
    * */
    void errorOptions(){
        for (int i = 1; i <= 6; i++) {

            new Thread(() ->{
                System.out.println(Thread.currentThread().getName() + "同学离开");
            }, String.valueOf(i)).start();
        }

        System.out.println(Thread.currentThread().getName() + "班长走了");
    }
}



CyclicBarrier


/*
*
* CyclicBarrier
*
* 刚好够多少个数量才能进行下去，  人够了才能开会
* */
public class CyclicBarrierDemo {

    //结果  做加法 达到多少个线程才会执行
    /*
    * 第1个龙珠
        第3个龙珠
        第5个龙珠
        第6个龙珠
        第4个龙珠
        第2个龙珠
        召唤神龙
    * */
    public static void main(String[] args) {

        //CyclicBarrier(int parties, Runnable barrierAction)
        CyclicBarrier cyclicBarrier = new CyclicBarrier(6, () ->{
            System.out.println("召唤神龙");
        });

        for (int i = 1; i <= 6; i++) {
            final int t = i;
            new Thread(() -> {
                System.out.println("第" + t + "个龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println(cyclicBarrier.getParties());

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



    }
}




读写锁


/*
*
* 多个线程同时读一个资源类没有任何问题， 所以为了满足并发量， 读取共享资源应该可以同时进行
*  但是
*   如果有一个线程想去写共享资源， 就不能应该再有其他线程可以对该资源进行读写
*   小结
*      读读 能共存
*      读写 不能共存
*      写写 不能共存
*
* 加读写锁的时候，  写入的时候不能背加塞， 一次性成功完成 ， 也完成了数据的完成性
* */

class MyCache{
    private volatile Map<String, Object> 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() + "开始写入");
            try {
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "写成功" + key);
        } finally {
            readWriteLock.writeLock().unlock();

        }

    }

    public Object read (String key){
        readWriteLock.readLock().lock();
        Object o;
        try {
            System.out.println(Thread.currentThread().getName() + "开始读");
            try {
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            o = map.get(key);
            System.out.println(Thread.currentThread().getName() + "读成功"  + o);
        } finally {

            readWriteLock.readLock().unlock();
        }
        return o;
    }
}
public class ReadWriteLockDemo {

    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 1; i <= 6; i++) {
            final int t = i;
            new Thread(() -> {
                myCache.put(t + "", t);
            }, String.valueOf(i)).start();
        }

        for (int i = 1; i <= 6; i++) {
            final int t = i;
            new Thread(() -> {
                myCache.read(t + "");
            }, String.valueOf(i)).start();
        }
    }
}



阻塞队列


JUC基础笔记（尚硅谷周阳JUC的笔记）_第4张图片


    

  • 当队列是空的， 从队列中获取元素的操作将会被阻塞
    • 

  • 当队列是满的， 从队列中添加元素的操作将会被阻塞。
    • 

  • 试图从空的队列中获取元素的线程将会被阻塞， 直到其他线程往空的队列出入新的元素
    • 

  • 试图向满的队列中添加新元素的线程将会被阻塞， 直到其他线程从队列中移除一个或者多个元素或者完全被清空， 使队列变得空闲起来并后续新增。
    • 

  • 在多线程领域： 所谓阻塞， 在某些情况下会被挂起线程， 一旦条件满足， 挂起的线程又会自动被唤醒
    • 

  • 为什么需要blockingQueue

      

    • 好处是我们不需要关心什么时候需要阻塞线程， 什么时候需要唤醒线程， 因为这一切BlockingQueue都给你一手包办了
      • 

    • 在concurent包发布以前， 在多线程环境下， 我们每个程序员都必须取自己控制这些细节， 尤其还有兼顾效率和线程安全， 而这会给我们的程序带来不小的复杂度。
      • 

    • JUC基础笔记（尚硅谷周阳JUC的笔记）_第5张图片
       JUC基础笔记（尚硅谷周阳JUC的笔记）_第6张图片
       JUC基础笔记（尚硅谷周阳JUC的笔记）_第7张图片
      • 

     
    • 



/*
* 阻塞队列
*  1、数据结构 栈和队列
*
*  2、阻塞队列
*     2、1 阻塞 必须要阻塞/不得不阻塞
*
*
* */

public class BlockingQueueDemo {

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

        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);

//        //true
//        System.out.println(blockingQueue.add("a"));
//        System.out.println(blockingQueue.add("b"));
//        System.out.println(blockingQueue.add("c"));
//        //再加就抛异常， 队列已满
        System.out.println(blockingQueue.add("d"));
        //得到队首
//        System.out.println(blockingQueue.element());
//
//        // 结果 a b c
//        System.out.println(blockingQueue.remove());
//        System.out.println(blockingQueue.remove());
//        System.out.println(blockingQueue.remove());
//        //空 抛出异常
//      //  System.out.println(blockingQueue.remove());
          // 队不满返回true
//        System.out.println(blockingQueue.offer("a"));
//        System.out.println(blockingQueue.offer("b"));
//        System.out.println(blockingQueue.offer("c"));
//        // 队满返回false
//        System.out.println(blockingQueue.offer("x"));
//
//        System.out.println(blockingQueue.poll());
//        System.out.println(blockingQueue.poll());
//        System.out.println(blockingQueue.poll());
//        //队空 返回空
//        System.out.println(blockingQueue.poll());
        //没有返回值
//        blockingQueue.put("a");
//        blockingQueue.put("a");
//        blockingQueue.put("a");
//        //队满 等待阻塞直到队有空间
        blockingQueue.put("a");
//
//        System.out.println(blockingQueue.take());
//        System.out.println(blockingQueue.take());
//        System.out.println(blockingQueue.take());
//        //队空阻塞
//        System.out.println(blockingQueue.take());

        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("b"));
        //队满 阻塞一定时间如果还不为空就走i
        System.out.println(blockingQueue.offer("z", 3L, TimeUnit.SECONDS));

    }
}




线程池


JUC基础笔记（尚硅谷周阳JUC的笔记）_第8张图片


    

  • Executors是一个工具类
     JUC基础笔记（尚硅谷周阳JUC的笔记）_第9张图片
    • 

  • 这个new的三个池子实际上都是调用的一样的处理方法
    • 



    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>(),
                                    threadFactory));
    }

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }



    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>(),
                                      threadFactory);
    }



    

  • 几个重要的参数（七个）
        public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {

     JUC基础笔记（尚硅谷周阳JUC的笔记）_第10张图片
    • 

  • 线程池的原理
     JUC基础笔记（尚硅谷周阳JUC的笔记）_第11张图片
     JUC基础笔记（尚硅谷周阳JUC的笔记）_第12张图片
    • 

  • 如何设置合理的参数

      

    • 再工作中用哪个哪一个都不用JUC基础笔记（尚硅谷周阳JUC的笔记）_第13张图片
      • 

     
    • 

  • 拒绝策略

      

    • abortPolicy(默认)：直接抛出 RejectedExecutionException
      • 

    • CallerRunPolicy: "调用者运行“ 一种调节机制，该策略即不会抛弃任务， 也不会抛出异常， 而是将某些任务回退到调用者， 从而降低新任务的流量（谁让你来找到线程池的就退回给谁）
      • 

    • discardOldestPolicy: 抛弃队列中等待最久的任务， 然后把当前任务加入队列中尝试在其提交任务
      • 

    • discardPolicy: 该策略默默地丢弃无法处理的任务， 不予任何处理也不报异常， 如果允许任务丢失， 这是最好的一种策略
      • 

     
    • 

  • 最大线程数选择

      

    • 如果是cpu密集型（计算型）选择cpu核心数加一

        

      • 可以利用这个得到内核数System.out.println(Runtime.getRuntime().availableProcessors());
        • 

       
      • 

    • I/o密集型（多I/o）选择 1/核数/阻塞系数
      • 

     
    • 



public class MyThreadPoolDemo {

   public static void main(String[] args) {
       //得到运行环境的cpu核心数
       System.out.println(Runtime.getRuntime().availableProcessors());
//        ExecutorService threadPool = new ThreadPoolExecutor( 2, 5, 2L,
//                                                          TimeUnit.MILLISECONDS,
//                                                          new LinkedBlockingQueue<>(3),
//                                                          Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
       /*
       * 用callerRunsPolicy 这个策略 当出现 等待区满了， max也满了 无法接续为新任务服务 就回退给调用者
       *   pool-1-thread-1办理业务
           pool-1-thread-3办理业务
           pool-1-thread-3办理业务
           main办理业务
           pool-1-thread-2办理业务
           pool-1-thread-5办理业务
           pool-1-thread-3办理业务
           pool-1-thread-1办理业务
           pool-1-thread-4办理业务
       * */
//        ExecutorService threadPool = new ThreadPoolExecutor( 2, 5, 2L,
//                                                                  TimeUnit.MILLISECONDS,
//                                                                  new LinkedBlockingQueue<>(3),
//                                                                  Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy());
       // 10进8 超过就直接放弃 （前提允许任务丢失）
//         ExecutorService threadPool = new ThreadPoolExecutor( 2, 5, 2L,
//                                                                          TimeUnit.MILLISECONDS,
//                                                                          new LinkedBlockingQueue<>(3),
//                                                                          Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardPolicy());
       // 抛弃等待队列中等待时间最长的 也就是队首
       ExecutorService threadPool = new ThreadPoolExecutor( 2, 5, 2L,
                                                                                 TimeUnit.MILLISECONDS,
                                                                                 new LinkedBlockingQueue<>(3),
                                                                                 Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardOldestPolicy());

       try {
           //模拟10个人办理银行办理业务  等待区满了， max也满了 无法接续为新任务服务 就拒绝（拒绝策略）
           for (int i = 1; i <= 9; i++) {
//                Thread.sleep(5);   //加上这个就不会出现超过8个线程就拒接， 因为有的就完成了
               threadPool.execute(() -> {
                   System.out.println(Thread.currentThread().getName() + "办理业务");
               });
           }
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           threadPool.shutdown();
       }
   }

   public void init(){
       //一个池中有几个线程
//        ExecutorService threadPool = Executors.newFixedThreadPool(5);
       //一个池中只有一个线程
//        ExecutorService threadPool = Executors.newSingleThreadExecutor();
       //执行很多短期异步任务， 线程池根据需要创建新线程， 但再先前构建的线程可用时将重用他们。 可扩容。
       ExecutorService threadPool = Executors.newCachedThreadPool();

       try {
           //模拟10个人办理银行办理业务
           for (int i = 1; i <= 10; i++) {
               threadPool.execute(() -> {
                   System.out.println(Thread.currentThread().getName() + "办理业务");
               });
           }
       } finally {
           threadPool.shutdown();
       }
   }
}



strem流式计算


    

  • java内置核心四大函数式接口
     JUC基础笔记（尚硅谷周阳JUC的笔记）_第14张图片
    • 



public class Funcations {
    public static void main(String[] args) {

        Consumer<String> consumer = s -> {
            System.out.println(s);
        };

        consumer.accept("Aaaa");

        Supplier<String> supplier = () -> {return "aaa";};


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


        Function<String, Integer> function = s -> {return Integer.parseInt(s);};

        System.out.println(function.apply("234"));

        Predicate<String> predicate = s -> {return !s.isEmpty();};
        System.out.println(predicate.test("aaaa"));

    }
}




    

  • 流到底是什么呢
     是数据渠道， 用于操作数据源（集合、数组等）所生成的元素序列。 “集合讲的是数据， 流讲的是计算”（筛选、过滤）
    • 

  • 特点： stream不会储存元素， stream不会改变源对象。 相反他们会返回一个持有结果的新stream， Stream操作时延迟执行的。 这意味着他们呢会等到需要结果的时候才执行。
    • 

  • 阶段（有三个处理流程）

      

    • 创建一个Stream :一个数据源（数组、集合）
      • 

    • 中间操作： 一个中间操作、进行处理数据源
      • 

    • 终止操作： 一个终止操作、执行中间操作链， 产生结果。
      • 

    • 源头 => 中间流水线 => 结果
      • 

     
    • 



public class Funcations {
    /*
    * 按照给定的数据， 找出同时满足以下条件的用户， 也即以下条件全部满足
    *  偶数Id且年龄大于24且用户名转为大写且用户名字母倒序
    *  只输出一个用户名字
    * */
    public static void main(String[] args) {

        User user1 = new User(11, "a", 23);
        User user2 = new User(12, "b", 24);
        User user3 = new User(13, "c", 22);
        User user4 = new User(14, "d", 28);
        User user5 = new User(16, "e", 26);

        List<User> list = Arrays.asList(user1, user2, user3, user4, user5);
        //filter过滤 map把每个返回值重新映射倒list sort排序 count计数
//        list.stream()
//                .filter(t -> {return t.getId() % 2 == 0 && t.getAge() > 24;})
//                .map(s -> {return s.getUsername().toUpperCase();})
//                .sorted((o1, o2) -> {return o2.compareTo(o1);}).limit(1)
//                .forEach(System.out::println);

        //这个省略大括号
        list.stream()
                .filter(t ->  t.getId() % 2 == 0 && t.getAge() > 24)
                .map(s -> {return s.getUsername().toUpperCase();})
                .sorted((o1, o2) -> {return o2.compareTo(o1);}).limit(1)
                .forEach(System.out::println);
        fun();
    }
    //四大函数式接口
    static void fun(){
        Consumer<String> consumer = s -> System.out.println(s);


        consumer.accept("Aaaa");

        Supplier<String> supplier = () ->"aaa";


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


        Function<String, Integer> function = s -> {return Integer.parseInt(s);};

        System.out.println(function.apply("234"));

        Predicate<String> predicate = s -> {return !s.isEmpty();};
        System.out.println(predicate.test("aaaa"));

    }
}
class User{

    private Integer id;
    private String username;
    private Integer age;

    public User() {
    }

    public User(Integer id, String username, Integer age) {
        this.id = id;
        this.username = username;
        this.age = age;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", age=" + age +
                '}';
    }
}



分支合并框架


    

  • ForkJoinPool
    • 

  • ForkJoinTask
    • 

  • RecursiveTask
    • 



/*
*
* 计算0 - 100进行分支计算
* */
class MyTask extends RecursiveTask<Integer>{

    private static final Integer ADJUST_VALUE = 10;

    private int begin;
    private int end;
    private int result;

    @Override
    protected Integer compute() {
        if (end - begin <= ADJUST_VALUE){
            for (int i = begin; i <= end; i ++) {
                result += i;
            }
        }else {
            int middle = (end + begin) / 2;
            MyTask task01 = new MyTask(begin, middle);
            MyTask task02 = new MyTask(middle + 1, end);
            task01.fork();
            task02.fork();
            result += task01.join() + task02.join();
        }
        return result;
    }


    public MyTask(int begin, int end) {
        this.begin = begin;
        this.end = end;
    }
}

public class ForkJoinDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyTask myTask = new MyTask(0, 100);

        ForkJoinPool threadPool = new ForkJoinPool();

        ForkJoinTask<Integer> submit = threadPool.submit(myTask);

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

        threadPool.shutdown();
    }
}



异步回调


    

  • CompletableFuturDemo
    • 



public class CompletableFutureDemo {

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

        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(
                () -> {
                    System.out.println("*****没有返回值");
                });
        completableFuture.get();
        //有返回值的异步
        CompletableFuture<Integer> completableFuture2 = CompletableFuture.supplyAsync(
                () -> {
                    System.out.println(Thread.currentThread().getName() + "有返回值");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    int age = 10 / 0;
                    return 1024;
                }
                );
        System.out.println("aaaa"); // 这个aaa先显示证明的却时异步的
        // 没有异常上一个分支， 有就走exceptionally分支
        System.out.println(completableFuture2.whenComplete((t, u) -> {
            System.out.println(t);
            System.out.println(u);
        }).exceptionally(f -> {
            System.out.println(f.getMessage());
            return 4444;
        }).get());

    }
}



JMM


    

  • volatile是java虚拟机提供的轻量级的同步机制

      

    • 保证可见性
      • 

    • 不保证原子性
      • 

    • 禁止指令重排
      • 

    • 只能修饰成员变量和静态成员变量
      • 

     
    • 



总结


在本次视频中周阳老师讲了juc常见的类， 以及如何使用，另外也讲了jdk8新出的stream以及函数式编程， 让我们大致了解了juc， 如果想学详细的推荐学 黑马那个JUC高级

























你可能感兴趣的:(juc)






    

  • Java基础 --- 多线程&JUC，以及一些常用的设计模式总结
lzhlizihang
java设计模式

    文章目录一、多线程1、线程和进程的区别2、创建多线程的四种方式3、集合中的线程安全二、设计模式1、单例模式2、装饰者模式（IO流缓冲流）3、适配器模式4、模板模式一、多线程1、线程和进程的区别进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位，一个进程可以运行多个线程多进程：操作系统中同时运行的多个程序多线程：在同一个进程中同时运行的多个任务2、创建多线程的四种方式Runna
    

    • 

  • Java 入门指南：Java 并发编程 —— 同步工具类 Semephore（信号量）
ZachOn1y
Javajava开发语言intellij-idea个人开发团队开发java-ee

    文章目录同步工具类Semephore核心功能限制并发访问量公平与非公平策略灵活性与适应性常用方法使用示例同步工具类JUC（Java.util.concurrent）是Java提供的用于并发编程的工具类库，其中包含了一些通信工具类，用于在多个线程之间进行协调和通信，特别是在多线程和网络通信方面。这些工具类提供了丰富的功能，帮助开发者高效地实现复杂的并发控制和网络通信需求。SemephoreSemap
    

    • 

  • Java 入门指南：Java 并发编程 —— 同步工具类 CountDownLatch（倒计时门闩）
ZachOn1y
Javajava后端个人开发java-ee团队开发

    文章目录同步工具类CountDownLatch常用方法使用步骤适用场景使用示例同步工具类JUC（Java.util.concurrent）是Java提供的用于并发编程的工具类库，其中包含了一些通信工具类，用于在多个线程之间进行协调和通信，特别是在多线程和网络通信方面。这些工具类提供了丰富的功能，帮助开发者高效地实现复杂的并发控制和网络通信需求。CountDownLatchCountDownLatc
    

    • 

  • Elasticsearch——配置详解
smart哥
elasticsearch专题elasticsearch搜索引擎

    作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！阶段1、深入多线程阶段2、深入多线程设计模式阶段3、深入juc源码解析阶段4、深入jdk其余源码解析阶段5、深入jvm源码解析码哥源码部分码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场
    

    • 

  • 大厂高频面试题复习JAVA学习笔记-学习路线
addaduvyhup
java开发语言

    对于应届生，要找到一份java工作，你得大概学会：java基础：javase、jvm、juc、gc、mysql、jdbc，计网计组Java微服务基础Maven→Gradle→Spring6→SpringMVC→MyBatis→MyBatisPlus→SSM->Redis7->SpringBoot2->SpringCloudjava微服务生态:Git-Docker-Elasticsearch→Zoo
    

    • 

  • 【编程底层思考】JUC中CAS的底层操作系统的实现原理及ABA问题
Dylanioucn
jvmjava开发语言

    一、何为CAS操作Java中的CAS操作，即Compare-And-Swap，是一种用于实现无锁编程的原子操作。在Java的java.util.concurrent.atomic包中，许多原子类都利用了CAS操作来保证复合操作的原子性。在底层操作系统层面，CAS通常由特定的CPU指令实现，这些指令能够检测内存中的值是否为预期值，并在条件满足的情况下，将其更新为新值。二、操作系统层面的CAS实现原理
    

    • 

  • 【JUC并发编程系列】深入理解Java并发机制：CAS算法与原子类在Java中的实践应用(二、CAS)
无理 Java
JUC并发编程系列javaJUC并发编程并发机制CAS后端面试

    文章目录【JUC并发编程系列】深入理解Java并发机制：CAS算法与原子类在Java中的实践应用(二、CAS)1.同步之原子类（Atomic类）2.使用atomicInteger计数3.使用atomicInteger底层原理3.compareAndSet原理分析3.1手写AtomicInteger3.2手写Lock锁3.3CASaba的问题3.4AtomicMarkableReference4.C
    

    • 

  • 使用C++和JUCE开发一个简单的音频插件
shuai_258
c++音视频开发语言

    简介在本教程中，我们将使用C++和JUCE框架来开发一个简单的音频插件。JUCE是一个功能强大的跨平台C++库，专注于音频应用的开发。我们将创建一个简单的增益（Gain）插件，能够实时调整音频信号的音量。准备工作在开始之前，请确保您的开发环境已经设置好。安装JUCE：下载并安装最新版本的JUCE（JUCE官网）。安装IDE：推荐使用VisualStudio或Xcode，如果你使用Linux，CLi
    

    • 

  • 【juce::translation】juce实现翻译文件生成器，多国语言显示
shuai_258
juce前端数据库c++

    translationFileBuilder(翻译文件生成器)1.1构造函数LocalisedStrings::LocalisedStrings(constString&fileContents,boolignoreCaseOfKeys)从翻译文件的文本创建一组翻译。当您创建其中一个映射时，您可以调用setCurrentMappings（）以使其成为系统正在使用的映射集。LocalisedStri
    

    • 

  • 问题未解决 | this.wait()和Thread.currentThread().wait()有啥区别
w_3123454
今天碰到了一个问题并发编程对象锁并发编程wait方法

    问题记录：this.wait()和Thread.currentThread().wait()有啥区别。从执行的结果看，使用前者能在执行a方法时把CPU让出去一会，最后会打印完所有数字。使用后者的话，也可以让出CPU，但是后续不会再打印a方法剩余的数字了。。。。。。。。。。。不明白这是为啥packagecom.example.juc;//演示持有同个对象锁的方法被多个线程同时调用的情况//结果持有同
    

    • 

  • JavaGuide知识点整理——集合使用注意事项总结
唯有努力不欺人丶

    这篇文章是根据阿里巴巴java开发手册总结了关于集合使用常见的逐一实现以及原理。集合判空判断所有集合内部的元素是否为空使用isEmpty()方法，而不是size()==0的方式。这是因为isEmpty()方法的可读性更好，并且时间复杂度为O(1).不过也有很多复杂度不是O(1)的，比如JUC包下的某些集合ConcurrentLinkedQueue、ConcurrentHashMap...下面是Co
    

    • 

  • JUC多线程与高并发（一）
JasonHuan1123
计算机类linuxjavajvm缓存

    1.谈谈对volatile的理解volatile是java虚拟机提供的一种轻量级的同步机制保证可见性不保证原子性禁止指令重排相当于轻量级的sychronized1.1.JMM的理解JMM，java内存模型JavaMemoryModel，是一种抽象的概念，并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。JMM关于同步的
    

    • 

  • 开源ETL工具
SkTj

    转载：https://blog.csdn.net/juceli/article/details/81448224ETL，是英文Extract-Transform-Load的缩写，用来描述将数据从来源端经过抽取(extract)、转换(transform)、加载(load)至目的端的过程。ETL是构建数据仓库的重要一环，用户从数据源抽取出所需的数据，经过数据清洗，最终按照预先定义好的数据仓库模型，将
    

    • 

  • 并发编程-JUC-原子类
developer@liyong
Java多线程与并发JavaCASABA原子类

    JUC整体概览原子类基本类型-使用原子的方式更新基本类型AtomicInteger：整形原子类AtomicLong：长整型原子类AtomicBoolean：布尔型原子类引用类型AtomicReference：引用类型原子类AtomicStampedReference：原子更新引用类型里的字段原子类AtomicMarkableReference：原子更新带有标记位的引用类型数组类型-使用原子的方式更
    

    • 

  • 并发编程-Synchronized
developer@liyong
Java多线程与并发Java管程锁升级synchronized

    什么是Synchronizedsynchronized是Java提供的一个关键字，Synchronized可以保证并发程序的原子性，可见性，有序性。我们会把synchronized称为重量级锁。主要原因，是因为JDK1.6之前，synchronized是一个重量级锁相比于JUC的锁显得非常笨重，存在性能问题。JDK1.6及之后，Java对synchronized进行的了一系列优化，性能与JUC的锁
    

    • 

  • java面试题/认证答辩 ---JUC并发包
Fuly1024
面试刷题jucJUC

    参考:>https://blog.csdn.net/xy3233/article/details/93607956JUC并发包包含:1）原子类（Atomic）2）锁框架（locks）3）同步器框架（AbstractQueuedSynchronizer）4）执行器框架（Executor）5）并发集合类Atomic类主要利用CAS(compareandswap)+volatile和native方法来保
    

    • 

  • 多线程并发编程10-CopyOnWriteArrayList源码剖析
Demo_zfs

    今天来说一说CopyOnWriteArrayList类，纵观JUC包下并发List只有CopyOnWriteArrayList类。CopyOnWriteArrayList是一个线程安全的ArrayList，从它的命名也能看出在进行写操作的时候会进行复制，这种写时复制策略会产生弱一致性问题。下面对CopyOnWriteArrayList类继续剖析。在CopyOnWriteArrayList类中都是围
    

    • 

  • 多线程&JUC：线程池原理、自定义线程池详细解析
布布要成为最负责的男人
多线程&JUCjava开发语言线程池JUC面试javase

    ‍作者简介：一位大四、研0学生，正在努力准备大四暑假的实习上期文章：多线程&JUC：等待唤醒机制（生产者消费者模式）订阅专栏：多线程&JUC希望文章对你们有所帮助线程池是一个比较好玩的东西，在做项目的过程中多少也是接触过的，在高并发的任务执行过程中就会经常自行创建线程池。在这里梳理一下线程池的原理，并且进行实践。线程池原理、自定义线程池详细解析线程池自定义线程池详细解析最大并行数线程池多大合适线程
    

    • 

  • Java 乐观锁和悲观锁
WYSCODER
Javajava程序人生开发语言

    文章目录Java乐观锁和悲观锁1、悲观锁2、乐观锁2.1CAS2.2模拟CAS算法2.3JUC2.4CAS中的ABA问题2.5使用CAS会引发的问题Java乐观锁和悲观锁1、悲观锁总是假设最坏的情况，每次在去获取共享数据的时候都认为别人会修改，所以每次都在获取数据的时候加锁。传统的关系型数据库里就用到很多这种锁，比如行锁，表锁、读锁、写锁等都是在操作之前先上锁，比如java中Synchronize
    

    • 

  • JUC并发编程---ReentrantLock源码分析
~clockwork~
Java

    1.ReentrantLockReentrantLock从名字看–重入锁（和synchronized关键字一样），同个线程在重复获取锁的话，会自动获取锁，而不是等待。ReentrantLock中又包含了公平锁、非公平锁的概念。下面列出构造函数和常用方法。publicclassReentrantLockimplementsLock,java.io.Serializable{privatefinalS
    

    • 

  • java阻塞唤醒线程之LockSupport
水煮鱼又失败了

    1场景这里介绍一个jdk自带的线程阻塞、唤醒工具LockSupport。此工具类属于juc包的一部分，所在包路径：java.util.concurrent.locks.LockSupport。2思维导图已将LockSupport相关的内容整理为思维导图如下：java阻塞唤醒线程之LockSupport.png3常用方法LockSupport的使用方法，均为static方法。常用方法如下：方法描述L
    

    • 

  • 为什么世界还存在饥荒，却舍得花几十亿元在航空航天事业
书荒杂谈

    今天主要是分享一篇来自美国航空航天局科学家给赞比亚修女的一封信背景：1970年，赞比亚修女玛丽·尤肯达给美国航空航天局科学家恩斯特·施图林格博士问道：目前地球上还有这么多小孩子吃不上饭，他怎么能舍得为远在火星的项目花费数十亿美元。1970年，赞比亚修女玛丽·尤肯达（MaryJucunda）给恩斯特·施图林格（ErnstStuhlinger）博士写了一封信。施图林格因在火星之旅工程中的原创性研究，成
    

    • 

  • JUC-java并发编程的艺术
HBryce24
并发java

    一、并发问题上下文切换：CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务。在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再加载这个任务的状态。所以任务从保存到再加载的过程就是一次上下文切换。多线程不一定快：多线程有线程创建和上下文切换的开销。减少上下文切换：无锁并发：多线程竞争锁时，会引起上下文切换，所以多线程处理数据时，可以用一些办法来避免使用锁
    

    • 

  • JUC-并发面试题
HBryce24
并发java

    一、基础1、为什么要并发编程充分利用多核CPU的资源2、并发编程存在的问题上下文切换：PU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务。在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再加载这个任务的状态。任务从保存到再加载的过程就是一次上下文切换。线程创建和上下文切换的带来而外的开销线程安全死锁：线程A持有资源，线程B持有资源；他们都想申请对方的资源
    

    • 

  • JUC：生产者消费者模式
ZRJ0618
JUCjava多线程

    文章目录虚假唤醒（spuriouswakeup）生产者与消费者模板生产者与消费者模式：synchronized虚假唤醒（spuriouswakeup）当需要条件判断使用wait()方法时，应该使用循环，而不是if，否则就可能会出现虚假唤醒（spuriouswakeup）的情况简单点理解，虚假唤醒就是除了理应被唤醒的线程之外，还另外唤醒了其它的线程，导致的数据的错误虚假唤醒的原理：例：publicc
    

    • 

  • 认识多线程：等待唤醒机制
斩天拔剑书
java编程思想

    packagecom.pccc.pactera.juc01;publicclassTestProducterAndConsumer{publicstaticvoidmain(String[]args){Clerkclerk=newClerk();Porductorp=newPorductor(clerk);Consumerc=newConsumer(clerk);newThread(p,"生产者A
    

    • 

  • 多线程详解&JUC
王叮咚
多线程java面试

    线程的基本知识1.线程的介绍1.1简介线程是进程中的一个实体，线程本身是不会独立存在的。进程是代码在数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，线程则是进程的一个执行路径，一个进程中至少有一个线程，进程中多个线程共享进程的资源。操作系统在分配资源时是把资源分配给进程的，但是CPU资源比较特殊。它是被分配到线程的，因为真正要占用CPU运行的是线程,所以也说线程是CPU分配的基本单位
    

    • 

  • JUC多线程编程之生产者与消费者问题（Synchronized和JUC版）
不会编程的派大星
JUC并发编程java多线程并发编程juc锁

    生产者与消费者问题在面试中，生产者与消费者是高频问题之一1.生产者和消费者问题Synchronized版publicclassA{publicstaticvoidmain(String[]args){Datadata=newData();newThread(()->{for(inti=0;i{for(inti=0;i{for(inti=0;i{for(inti=0;i"+number);//通知其
    

    • 

  • Java 的 多线程&JUC
三池丶
javajvm开发语言

    目录什么是多线程？并发和并行多线程的实现方式多线程的第一种实现方式多线程的第二种实现方式多线程的第三种实现方式小结多线程中常见的成员方法常用简单方法线程的优先级守护线程（备胎线程）礼让线程和插入线程(了解)线程的生命周期线程安全的问题同步代码块同步方法Lock锁死锁多线程的等待唤醒机制（生产者和消费者）消费者代码实现生产者代码实现总体代码实现阻塞队列实现等待唤醒机制线程的状态综合练习一线程栈线程池
    

    • 

  • 多线程 生产者与消费者 遇到的问题以及解决方法
小白鼠丶
多线程JUC多线程生产者消费者

    目录最原始的生产者消费者模型问题一：产品product>=1时wait问题二：增加一些消费者和生产者线程最原始的生产者消费者模型packagecom.juc;/**生产者和消费者案例*/publicclassTestProductorAndConsumer1{publicstaticvoidmain(String[]args){Clerkclerk=newClerk();Productorpro=
    

    • 

  • ztree设置禁用节点
3213213333332132
JavaScriptztreejsonsetDisabledNodeAjax

    ztree设置禁用节点的时候注意，当使用ajax后台请求数据,必须要设置为同步获取数据，否者会获取不到节点对象，导致设置禁用没有效果。
$(function(){
showTree();
setDisabledNode();
});

    

    • 

  • JVM patch by Taobao
bookjovi
javaHotSpot

    在网上无意中看到淘宝提交的hotspot patch，共四个，有意思，记录一下。
 
7050685：jsdbproc64.sh has a typo in the package name
7058036：FieldsAllocationStyle=2 does not work in 32-bit VM
7060619：C1 should respect inline and
    

    • 

  • 将session存储到数据库中
dcj3sjt126com
sqlPHPsession

    CREATE TABLE sessions (
id CHAR(32) NOT NULL,
data TEXT,
last_accessed TIMESTAMP NOT NULL,
PRIMARY KEY (id)
);
 
<?php
/**
* Created by PhpStorm.
* User: michaeldu
* Date
    

    • 

  • Vector
171815164
vector

    public Vector<CartProduct> delCart(Vector<CartProduct> cart, String id) {
for (int i = 0; i < cart.size(); i++) {
if (cart.get(i).getId().equals(id)) {
cart.remove(i);

    

    • 

  • 各连接池配置参数比较
g21121
连接池

            排版真心费劲，大家凑合看下吧，见谅~
 
 
Druid
DBCP
C3P0
Proxool
数据库用户名称 Username Username User  
数据库密码 Password Password Password  
驱动名
    

    • 

  • [简单]mybatis insert语句添加动态字段
53873039oycg
mybatis

          mysql数据库,id自增,配置如下：
     
<insert id="saveTestTb" useGeneratedKeys="true" keyProperty="id"
parameterType=&
    

    • 

  • struts2拦截器配置
云端月影
struts2拦截器

    struts2拦截器interceptor的三种配置方法
方法1. 普通配置法
<struts>
    <package name="struts2" extends="struts-default">
        &
    

    • 

  • IE中页面不居中，火狐谷歌等正常
aijuans
IE中页面不居中

    问题是首页在火狐、谷歌、所有IE中正常显示，列表页的页面在火狐谷歌中正常，在IE6、7、8中都不中，觉得可能那个地方设置的让IE系列都不认识，仔细查看后发现，列表页中没写HTML模板部分没有添加DTD定义，就是<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3
    

    • 

  • String,int,Integer,char 几个类型常见转换
antonyup_2006
htmlsql.net

    如何将字串 String 转换成整数 int?
int i = Integer.valueOf(my_str).intValue();
int i=Integer.parseInt(str);
如何将字串 String 转换成Integer ?
Integer integer=Integer.valueOf(str);
如何将整数 int 转换成字串 String ?
1.
    

    • 

  • PL/SQL的游标类型
百合不是茶
显示游标(静态游标)隐式游标游标的更新和删除%rowtyperef游标(动态游标)

    游标是oracle中的一个结果集,用于存放查询的结果;
 
PL/SQL中游标的声明;
1,声明游标
2,打开游标(默认是关闭的);
3,提取数据
4,关闭游标
 
 
注意的要点:游标必须声明在declare中,使用open打开游标,fetch取游标中的数据,close关闭游标
 
隐式游标:主要是对DML数据的操作隐
    

    • 

  • JUnit4中@AfterClass @BeforeClass @after @before的区别对比
bijian1013
JUnit4单元测试

    一.基础知识
JUnit4使用Java5中的注解（annotation），以下是JUnit4常用的几个annotation： @Before：初始化方法   对于每一个测试方法都要执行一次（注意与BeforeClass区别，后者是对于所有方法执行一次）@After：释放资源  对于每一个测试方法都要执行一次（注意与AfterClass区别，后者是对于所有方法执行一次
    

    • 

  • 精通Oracle10编程SQL(12)开发包
bijian1013
oracle数据库plsql

    /*
*开发包
*包用于逻辑组合相关的PL/SQL类型（例如TABLE类型和RECORD类型）、PL/SQL项（例如游标和游标变量）和PL/SQL子程序（例如过程和函数）
*/
--包用于逻辑组合相关的PL/SQL类型、项和子程序，它由包规范和包体两部分组成
--建立包规范：包规范实际是包与应用程序之间的接口，它用于定义包的公用组件，包括常量、变量、游标、过程和函数等
--在包规
    

    • 

  • 【EhCache二】ehcache.xml配置详解
bit1129
ehcache.xml

    在ehcache官网上找了多次，终于找到ehcache.xml配置元素和属性的含义说明文档了，这个文档包含在ehcache.xml的注释中！
ehcache.xml ： http://ehcache.org/ehcache.xml
ehcache.xsd ： http://ehcache.org/ehcache.xsd
ehcache配置文件的根元素是ehcahe
  ehcac
    

    • 

  • java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderL
白糖_
javaeclipsespringtomcatWeb

    今天学习spring+cxf的时候遇到一个问题：在web.xml中配置了spring的上下文监听器：
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
 随后启动
    

    • 

  • angular.element
boyitech
AngularJSAngularJS APIangular.element

    angular.element
描述:     包裹着一部分DOM element或者是HTML字符串，把它作为一个jQuery元素来处理。（类似于jQuery的选择器啦）     如果jQuery被引入了，则angular.element就可以看作是jQuery选择器，选择的对象可以使用jQuery的函数；如果jQuery不可用，angular.e
    

    • 

  • java-给定两个已排序序列，找出共同的元素。
bylijinnan
java

    
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class CommonItemInTwoSortedArray {
/**
* 题目：给定两个已排序序列，找出共同的元素。
* 1.定义两个指针分别指向序列的开始。
* 如果指向的两个元素
    

    • 

  • sftp 异常，有遇到的吗？求解
Chen.H
javajcraftauthjschjschexception

    com.jcraft.jsch.JSchException: Auth cancel
at com.jcraft.jsch.Session.connect(Session.java:460)
at com.jcraft.jsch.Session.connect(Session.java:154)
at cn.vivame.util.ftp.SftpServerAccess.connec
    

    • 

  • [生物智能与人工智能]神经元中的电化学结构代表什么?
comsci
人工智能

         我这里做一个大胆的猜想,生物神经网络中的神经元中包含着一些化学和类似电路的结构,这些结构通常用来扮演类似我们在拓扑分析系统中的节点嵌入方程一样,使得我们的神经网络产生智能判断的能力,而这些嵌入到节点中的方程同时也扮演着"经验"的角色....
     我们可以尝试一下...在某些神经
    

    • 

  • 通过LAC和CID获取经纬度信息
dai_lm
laccid

    方法1：
用浏览器打开http://www.minigps.net/cellsearch.html，然后输入lac和cid信息(mcc和mnc可以填0)，如果数据正确就可以获得相应的经纬度
方法2：
发送HTTP请求到http://www.open-electronics.org/celltrack/cell.php?hex=0&lac=<lac>&cid=&
    

    • 

  • JAVA的困难分析
datamachine
java

    前段时间转了一篇SQL的文章（http://datamachine.iteye.com/blog/1971896），文章不复杂，但思想深刻，就顺便思考了一下java的不足，当砖头丢出来，希望引点和田玉。
 
-----------------------------------------------------------------------------------------
    

    • 

  • 小学5年级英语单词背诵第二课
dcj3sjt126com
englishword

    money 钱
paper 纸
speak 讲，说
tell 告诉
 
remember 记得，想起
knock 敲，击，打
question 问题
number 数字，号码
 
learn 学会，学习
street 街道
carry 搬运，携带
send 发送，邮寄，发射
 
must 必须
light 灯，光线，轻的
front 
    

    • 

  • linux下面没有tree命令
dcj3sjt126com
linux

    centos p安装
yum -y install tree
 
mac os安装
brew install tree
  首先来看tree的用法
tree 中文解释：tree
功能说明：以树状图列出目录的内容。
语　　法：tree [-aACdDfFgilnNpqstux][-I <范本样式>][-P <范本样式
    

    • 

  • Map迭代方式，Map迭代，Map循环
蕃薯耀
Map循环Map迭代Map迭代方式

    Map迭代方式，Map迭代，Map循环
 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
蕃薯耀 2015年
    

    • 

  • Spring Cache注解+Redis
hanqunfeng
spring

    Spring3.1 Cache注解 
依赖jar包：
<!-- redis -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>

    

    • 

  • Guava中针对集合的 filter和过滤功能
jackyrong
filter

    在guava库中，自带了过滤器(filter)的功能，可以用来对collection 进行过滤，先看例子：
  
@Test
public void whenFilterWithIterables_thenFiltered() {
List<String> names = Lists.newArrayList("John"
    

    • 

  • 学习编程那点事
lampcy
编程androidPHPhtml5

    一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！
接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
    

    • 

  • 架构师之流处理---------bytebuffer的mark,limit和flip
nannan408
ByteBuffer

    1.前言。
  如题，limit其实就是可以读取的字节长度的意思，flip是清空的意思，mark是标记的意思 。
2.例子.
例子代码:
String str = "helloWorld";
ByteBuffer buff = ByteBuffer.wrap(str.getBytes());
Sy
    

    • 

  • org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1, column 1
Everyday都不同
$转义el表达式

    最近在做Highcharts的过程中，在写js时，出现了以下异常：
 
严重: Servlet.service() for servlet jsp threw exception
org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1, 
    

    • 

  • 用Java实现发送邮件到163
tntxia
java实现

    /*
在java版经常看到有人问如何用javamail发送邮件？如何接收邮件？如何访问多个文件夹等。问题零散，而历史的回复早已经淹没在问题的海洋之中。
本人之前所做过一个java项目，其中包含有WebMail功能，当初为用java实现而对javamail摸索了一段时间，总算有点收获。看到论坛中的经常有此方面的问题，因此把我的一些经验帖出来，希望对大家有些帮助。
此篇仅介绍用
    

    • 

  • 探索实体类存在的真正意义
java小叶檀
POJO

    一. 实体类简述  
 实体类其实就是俗称的POJO,这种类一般不实现特殊框架下的接口，在程序中仅作为数据容器用来持久化存储数据用的
POJO（Plain Old Java Objects）简单的Java对象
 
它的一般格式就是
public class A{
private String id;
public Str
    

    •