一叶孤舟*

JUC并发编程(多线程进阶)

1、什么是JUC

java.util工具包

Runnable没有返回值，效率相比于Callable相对较低

2、线程和进程

进程：一个程序的集合。
一个进程至少包含多个线程，至少包含一个。
java默认有2个线程。
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多核，多个线程可以同时执行

public class Test01 {
    public static void main(String[] args) {
        //获取cpu的核数
        //cpu密集型，IO密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

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

线程有几个状态

public enum State {
         //新生
        NEW,

         //运行
        RUNNABLE,

         //阻塞
        BLOCKED,
		
		//等待，死死的等待
        WAITING,

        //超时等待
        TIMED_WAITING,

       //终止
        TERMINATED;
    }

wait/sleep区别

1、来自不同的类
wait =》object
sleep =》Thread

2、关于锁的释放
wait会释放锁；sleep睡觉了，抱着锁睡，不会释放。

3、使用的范围是不同的

wait：必须在同步代码块中
sleep：可以在任何地方使用。

4、是否需要捕获异常

wait一般是不需要捕获异常，但可能会存在中断异常。
sleep必须要捕获异常

3、Lock锁（重点）

传统的synchronized方式

public class SaleTicketDemo1 {
    public static void main(String[] args) {
        //并发：多线程操作同一个资源类，把资源类丢入线程
        final Ticket ticket = new Ticket();

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

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

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

//资源类oop
class Ticket{
    //属性，方法
    private int number = 50;

    //卖票的方式
    //synchronized的本质：对列，锁
    public synchronized void sale(){
        if (number>0){
            System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"票，剩余："+number);
        }
    }
}

Lock接口

公平锁：十分公平，可以先来后到。
非公平锁：十分不公平，可以插队。（默认）

public class SaleTicketDemo2 {
    public static void main(String[] args) {
        //并发：多线程操作同一个资源类，把资源类丢入线程
        Ticket2 ticket = new Ticket2();

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

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

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

//资源类oop
class Ticket2{
    //属性，方法
    private int number = 50;

    Lock lock = new ReentrantLock();

    public void sale(){

        lock.lock();//加锁

        //业务代码
        try {
            if (number>0){
                System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"票，剩余："+number);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } 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.slime.pc;

public class A {
    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();
    }
}

思考：两个线程没有什么问题，那多个线程是否会出现问题呢？
增加两个线程后测试，结果明显出错了。

怎么解决虚假唤醒？

if 改为 while 判断

结果：

JUC版的生产者和消费者的问题

通过Lock找到Condition

代码实现：

package com.slime.pc;

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

public class B {
    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.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

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

class Data2{

    private int number = 0;

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

    //+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 (Exception 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 (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

问题：现在线程执行出来的结果是随机实现的，我们想要控制线程有序执行该怎么做呢？

5、Condition

1、Condition是什么？
精准的通知和唤醒线程

2、代码实现

package com.slime.pc;

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

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

        Data3 data = new Data3();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printA();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printB();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printC();
            }
        },"C").start();

    }
}

class Data3{
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    private int number = 1;

    public void printA(){
        lock.lock();

        try {
            while (number != 1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAAAAA");
            //唤醒，唤醒指定的人,B
            number = 2;
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB(){
        lock.lock();

        try {
            while (number != 2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>BBBBBB");
            //唤醒，唤醒指定的人,B
            number = 3;
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC(){
        lock.lock();

        try {
            while (number != 3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>CCCCCC");
            //唤醒，唤醒指定的人,B
            number = 1;
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

3、结果：有序执行

6、八锁现象

四个案例详解

1、

package com.slime.lock8;

import java.util.concurrent.TimeUnit;

//问题：先打印出来发短信还是打电话？
public class Test1 {
    public static void main(String[] args) {
        Phone phone  = new Phone();

        //不是先调用了发短信的方法的原因，而是锁的问题
        new Thread(()->{
            phone.sendms();
        },"A").start();

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

//synchronized锁的对象是方法的调用者
//这里只有一把锁，两个方法用的都是这把锁，所以谁先拿到谁执行。
class Phone{
    public synchronized void sendms(){

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

        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }
}

2、

package com.slime.lock8;

import java.util.concurrent.TimeUnit;

//增加了一个普通方法hello，现在是先执行发短信还是hello
public class Test2 {
    public static void main(String[] args) {
        //两个对象，两个调用者，两把锁，
        Phone2 phone  = new Phone2();
        Phone2 phone2 = new Phone2();

        //不是先调用了发短信的方法的原因，而是锁的问题
        new Thread(()->{
            phone.sendms();
        },"A").start();

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


class Phone2{
    public synchronized void sendms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }

    //这里没有锁，不是同步方法。不受锁的影响
    public void hello(){
        System.out.println("Hello");
    }
}

3、

package com.slime.lock8;

import java.util.concurrent.TimeUnit;

//增加两个静态的同步方法，只有一个对象，先打印发短信还是打电话
public class Test3 {
    public static void main(String[] args) {
        //两个对象的class类模板只有一个，static，锁的是class
        Phone3 phone  = new Phone3();
        Phone3 phone2  = new Phone3();

        //锁的存在
        new Thread(()->{
            phone.sendms();
        },"A").start();

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

//Phone3唯一的一个class对象
class Phone3{
    //synchronized锁的对象是方法的调用者
    //static静态方法
    //类一加载就有了，锁的是class
    public static synchronized void sendms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }

    public static synchronized void call(){
        System.out.println("打电话");
    }
}

4、

package com.slime.lock8;

import java.util.concurrent.TimeUnit;

//1个静态的同步方法，1个普通的同步方法，一个对象，先打印发短信还是打电话
public class Test4 {
    public static void main(String[] args) {
        //两个对象的class类模板只有一个，static，锁的是class
        Phone4 phone  = new Phone4();
        Phone4 phone2  = new Phone4();

        //锁的存在
        new Thread(()->{
            phone.sendms();
        },"A").start();

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

//Phone3唯一的一个class对象
class Phone4{

    //静态的同步方法，锁的是class类模板
    public static synchronized void sendms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }

    //普通的同步方法
    public  synchronized void call(){
        System.out.println("打电话");
    }
}

小结

如果只有一把锁，两个方法都使用这把相同的锁，那么谁先拿到谁先执行（案例一）
如果有一个方法没有上锁，那么就不受锁的影响，会先执行这个方法。（案例二）
如果两个加锁的方法都是用static修饰的静态方法，那么还是会依次执行（案例三）
如果两个加锁的方法一个是静态的同步方法，一个是普通的同步方法，并且静态的同步方法加上了延迟，那么就会先执行普通的同步方法。

7、集合类不安全

List不安全

//java.util.ConcurrentModificationException : 并发修改异常
public class ListTest {
    public static void main(String[] args) {
        //并发下ArrayList不安全的

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

        //CopyOnWrite写入时复制

        List<String> 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不安全

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

        /*
        * 同理可证：java.util.ConcurrentModificationException
        * 解决方案：
        * 1、Set set = Collections.synchronizedSet(new HashSet<>());
        * 2、Set set = new CopyOnWriteArraySet<>();
        */

        //Set set =  new HashSet<>();
        //Set set = Collections.synchronizedSet(new HashSet<>());
        Set<String> 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 set 的本质就是map key是无法重复的
public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

Map不安全

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

        //Mapmap = new ConcurrentHashMap<>();
        Map<String , String>map = new ConcurrentHashMap<>();

        for (int i = 1; i <= 30; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

8、Callable

1、可以有返回值
2、可以抛出异常
3、方法不同，run()/ call()

代码实现：

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        new Thread().start();

        MyThread thread = new  MyThread();
        FutureTask futureTask = new FutureTask(thread);//适配类

        new Thread(futureTask,"A").start();

        Integer o = (Integer) futureTask.get();
        System.out.println(o);
    }
}

class MyThread implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        System.out.println("call");
        return 1024;
    }
}

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

9、常用的辅助类

9.1、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();//数量-1
            },String.valueOf(i)).start();
        }

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

        System.out.println("Close Door");
    }
}

原理：

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

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

每次有线程调用countDown()数量-1，假设计数器变为0，countDownLatch.await()就会被唤醒，继续执行！

9.2、CyclicBarrier

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        //集齐七颗龙珠召唤神龙

        //召唤龙珠的线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("召唤神龙成功");
        });

        for (int i = 1; i <= 7; i++) {
            final int temp = i;
            //lambda能操作到i吗
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集"+temp+"个龙珠");
                try {
                    //等待
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

9.3、Semaphore

Semaphore：信号量

案例：抢车位==》6辆车抢3个车位

public class SemaphoreDemo {
    public static void main(String[] args) {
        //线程数量：停车位
        Semaphore semaphore = new Semaphore(3);

        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                //acquire()得到
                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 {
                    //release()释放
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}

原理：

semaphore.acquire() ：获得，假设如果已经满了，等待，等待被释放为止。

semaphore.release() ：释放，会将当前的信号量释放+1，然后唤醒等待的线程。

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

10、读写锁

ReadWriteLock

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCacheLock myCache = new MyCacheLock();

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

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

//自定义缓存
class MyCache{
    private volatile Map<String,Object> 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");
    }
}

结果：

很明显，线程在执行的时候被其他线程随意的插入，这就造成了线程执行的混乱。

那怎么解决这个问题呢？（加锁）

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCacheLock myCache = new MyCacheLock();

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

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

class MyCacheLock{
    private volatile Map<String,Object> map = new HashMap<>();

    //读写锁：更加细粒度的控制
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private Lock lock = new ReentrantLock();

    //存，写入的时候，只希望同时只有一个线程写
    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();
        }

    }
}

结果：

ReadWriteLock

读-读可以共存
读-写不能共存
写-写不能共存
独占锁（写锁）一次只能被一个线程占有
共享锁（读锁）多个线程可以同时占有

11、阻塞队列

写入：如果队列满了，就必须阻塞等待
取：如果队列是空的，必须阻塞等待生产

BlockingQueue：不是什么新的知识点

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

11.1、四组API

1、抛出异常

添加：add
移除：remove
检测队首元素：element()

public class Test {
    public static void main(String[] args) {
        test1();
    }

 /*
    * 功能描述：抛出异常
    * @author:wzm
    * @return:
    * @date: 2020/5/31 14:04
    */
 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(blockingQueue.element());
        
        System.out.println("======================");

        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());

        //java.util.NoSuchElementException  (队列已空，没有元素)
        System.out.println(blockingQueue.remove());

    }
}

2、有返回值，不会抛出异常

添加：offer
移除：poll
检测队首元素：peek()

public class Test {
    public static void main(String[] args) {
        test2();
    }
    
	/*
    * 功能描述：有返回值，没有异常
    * @author:wzm
    * @return:
    * @date: 2020/5/31 14:18
    */
    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"));

        //false 不抛出异常
        System.out.println(blockingQueue.offer("d"));

 		//查看队首元素是谁
        System.out.println(blockingQueue.peek());
        
        System.out.println("===========================");

        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        
        //null,不抛出异常
        System.out.println(blockingQueue.poll());
    }
}

3、阻塞等待

put()
take()

public class Test {
    public static void main(String[] args) throws InterruptedException {
        test3();
    }
/*
    * 功能描述：等待，阻塞
    * @author:wzm
    * @return:
    * @date: 2020/5/31 14:30
    */
    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());

    }
}

4、超时等待

添加：offer
移除：poll

public class Test {
    public static void main(String[] args) throws InterruptedException {
        test4();
    }
/*
    * 功能描述：等待，阻塞(等待超时)
    * @author:wzm
    * @return:
    * @date: 2020/5/31 14:50
    */
    public static void test4() throws InterruptedException {
        //队列的大小
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        blockingQueue.offer("a");
        blockingQueue.offer("b");
        blockingQueue.offer("c");
        //等待超过2秒就退出
        //blockingQueue.offer("d",2, TimeUnit.SECONDS);

        System.out.println("=================");

        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        //等待超过2秒就退出
        blockingQueue.poll(2,TimeUnit.SECONDS);
    }
}

11.2、SynchronousQueue 同步队列

/*
* 功能描述：同步队列
* @author:wzm
* @return:
* @date: 2020/5/31 15:08
*/
public class SynchronousQueueDemo {
    public static void main(String[] args) {
        //同步队列
        SynchronousQueue<String> 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 (Exception e) {
                e.printStackTrace();
            }
        },"T1").start();

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

12、线程池

线程池：三大方法，7大参数，4种拒绝策略

池化技术

程序的运行、本质：占用系统的资源！优化资源的使用 => 池化技术
池化技术：事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我。

线程池的好处：
1、降低资源的消耗
2、提高响应的速度
3、方便管理

线程复用、可以控制最大并发数、管理线程

线程池：三大方法

//Executors 工具类、3大方法
public class Demo1 {
    public static void main(String[] args) {
        //ExecutorService executorService = Executors.newSingleThreadExecutor();//单个线程
        //ExecutorService executorService = Executors.newFixedThreadPool(5);//创建一个固定的线程池的大小
        ExecutorService executorService = Executors.newCachedThreadPool();//可伸缩的，遇强则强，遇弱则弱

        try {
                    for (int i = 0; i < 10; i++) {
                        //使用了线程池之后，使用线程池来创建线程
                        executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" OK");
            });
        }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    //线程池用完，程序结束，关闭线程池
                    executorService.shutdown();
                }
    }
}

7大参数，四种拒绝策略

public class Demo1 {
    public static void main(String[] args) {
        //ExecutorService executorService = Executors.newSingleThreadExecutor();//单个线程
        //ExecutorService executorService = Executors.newFixedThreadPool(5);//创建一个固定的线程池的大小
        //ExecutorService executorService = Executors.newCachedThreadPool();//可伸缩的，遇强则强，遇弱则弱

        ExecutorService executorService = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                //拒绝策略
                new ThreadPoolExecutor.DiscardOldestPolicy()
        );

        try {
                    for (int i = 0; i < 9; i++) {
                        //使用了线程池之后，使用线程池来创建线程
                        executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" OK");
            });
        }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    //线程池用完，程序结束，关闭线程池
                    executorService.shutdown();
                }
    }
}

new ThreadPoolExecutor.AbortPolicy() //线程池满了，还有线程进来，不处理这个线程，抛出异常
new ThreadPoolExecutor.CallerRunsPolicy() //哪里执行的线程回哪里去处理
new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢掉这个任务，不会抛出异常
new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试去和最早的执行线程竞争，如果竞争失败了依旧会丢掉这个线程，成功了就会执行这个线程

小结和拓展

了解：IO密集型，CPU密集型：（调优）

最大线程到底该如何定义
1、cpu 密集型几核，就是几，可以保持cpu的效率最高
2、IO 密集型 > 判断你程序中十分耗IO的线程

13、四大函数式接口

函数式接口：只有一个方法的接口

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

@FunctionalInterface在java程序中广泛存在
可以简化编程模型，在新版本的框架底层大量应用
foreach（消费者类的函数式接口）

代码测试：

Function （函数式接口）

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

        /*Function function = new Function() {
            @Override
            public String apply(String str) {
                return str;
            }
        };*/

        Function<String,String> function = (str)->{return str;};

        System.out.println(function.apply("asd"));
    }
}

Predicate （断定型接口）：有一个输入参数，返回值只能是布尔值

public class Demo2 {
    public static void main(String[] args) {
        //判断字符串是否为空
        /*Predicatepredicate = new Predicate() {
            @Override
            public boolean test(String s) {
                return s.isEmpty();
            }
        };*/

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

Consumer （消费型接口）：只有输入，没有返回值

public class Demo3 {
    public static void main(String[] args) {
        /*Consumer consumer = new Consumer() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };*/
        Consumer<String> consumer = (s)->{
            System.out.println(s);
        };
        consumer.accept("一叶孤舟");
    }
}

Supplier（供给型接口）：没有参数，只有返回值

public class Demo4 {
    public static void main(String[] args) {
        /*Supplier supplier = new Supplier() {
            @Override
            public Integer get() {
                return 1024;
            }
        };*/

        Supplier supplier = ()->{return 1024;};
        System.out.println(supplier.get());
    }
}

14、Stream流式计算

代码实现：
1、实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {

    private int id;
    private String name;
    private int age;

}

2、测试类

/*
* 现在有5个用户，筛选：
* 1、ID必须是偶数
* 2、年龄必须大于23岁
* 3、用户名转为大写字母
* 4、用户名字母倒着排序
* 5、只输出一个用户
*/
public class Test {
    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);

        //集合就是存储
        List<User> list = Arrays.asList(u1,u2,u3,u4,u5);

        //计算交给Stream流
        //链式编程
        list.stream()
                .filter(u->{return u.getId()%2 == 0;})
                .filter(u->{return u.getAge()>23;})
                .map(u->{return u.getName().toUpperCase();})
                .sorted((uu1,uu2)->{return uu2.compareTo(uu1);})
                .limit(1)
                .forEach(System.out::println);

    }
}

15、ForkJoin

什么是ForkJoin

ForkJoin在JDK1.7中添加，用处是并行执行任务，提高效率，

ForkJoin的特点：工作窃取

当B线程执行完了之后，A线程还没执行完；B线程就会去执行A线程没有执行完的部分，这就是工作窃取。

代码实现：

public class ForkJoinDemo extends RecursiveTask<Long> {

    private Long start;
    private Long end;

    //临界值
    private Long temp = 10000L;

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

    //计算方法
    @Override
    protected Long compute() {
        if ((end - start) < temp) {
            Long sum = 0L;
            for (Long i = start;i <= end;i++){
                sum += i;
            }
            return sum;
        } else {
            long middle = (start + end) / 2;
            ForkJoinDemo task1 = new ForkJoinDemo(start,middle);
            task1.fork();   //拆分任务，把任务压入线程队列
            ForkJoinDemo task2 = new ForkJoinDemo(middle+1,end);
            task2.fork();   //拆分任务，把任务压入线程队列

            return task1.join() + task2.join();
        }
        }
    }

测试类：

package com.slime.forkjoin;

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

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //test1(); 
        //test2();  
        test3();
    }

    //普通程序员
    public static void test1(){
        Long sum = 0L;
        long start = System.currentTimeMillis();
        for (Long i = 1L; i < 10_0000_0000; i++) {
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+"时间："+(end-start));
    }

    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(0L, (long) 10_0000_0000);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);//提交任务
        Long sum = submit.get();

        long end = System.currentTimeMillis();

        System.out.println("sum="+sum+"时间："+(end-start));
    }

    public static void test3(){
        long start = System.currentTimeMillis();
        //Stream并行流()
        long sum = LongStream.rangeClosed(0L,10_0000_0000).parallel().reduce(0,Long::sum);
        long end = System.currentTimeMillis();
        System.out.println("sum="+"时间："+(end-start));
    }
}

16、异步回调

Future设计的初衷：对将来的某个事情的结果进行建模

package com.slime.future;


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

public class Demo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
       /*//没有返回值的runAsync异步回调
        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("111");

        //获取阻塞执行结果
        completableFuture.get();*/


        //有返回值的runAsync异步回调
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
            return 1024;
        });

        System.out.println(completableFuture.whenComplete((t,u)->{
            System.out.println("t=>"+t); //正常的返回结果
            System.out.println("u=>"+u); //错误的信息
        }).exceptionally((e)->{
            System.out.println(e.getMessage());
            return 233; //可以获取到错误的返回结果
        }).get());
    }
}

17、JMM

请你谈谈你对Volatile的理解

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

好处：

1、保证可见性
2、不保证原子性
3、禁止指令重排

什么是JMM

JMM：java内存模型，不存在的东西，概念，约定

关于JMM的一些同步的约定：
1、线程解锁前，必须把共享变量立刻刷回主存
2、线程加锁前，必须读取主存中的最新值到工作内存中
3、加锁和解锁是同一把锁

线程工作内存、主内存
8种操作：

问题：线程B修改了值，但是线程A不能及时可见

内存交互操作:
内存交互操作有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操作之前，必须把此变量同步回主内存

代码测试：

public class JMMDemo {

    private static int num = 0;

    public static void main(String[] args) {

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

            }
        }).start();

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

        num = 1;

        System.out.println(num);

    }
}

结果：
程序会陷入死循环，原因是主存不知道线程修改了值。

18、volatile

1、保证可见性

public class JMMDemo {

    //不加volatile程序就会死循环
    private volatile static int num = 0;

    public static void main(String[] args) {

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

            }
        }).start();

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

        num = 1;

        System.out.println(num);

    }
}

结果：

2、不保证原子性

原子性：不可分割

线程A在执行任务的时候，不能被打扰的，也不能被分割。要么同时成功，要么同时失败。

//volatile 不保证原子性
public class VDemo02 {

    private volatile static int num = 0;

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

    public static void main(String[] args) {

        //理论上num结果应该为2万
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        while (Thread.activeCount()>2){
            Thread.yield();
        }

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

如果不加lock和synchronized，怎么样保证原子性

//volatile 不保证原子性
public class VDemo02 {

    //volatile 不保证原子性
    //原子类的Integer
    private volatile static AtomicInteger num = new AtomicInteger();

    public static void add(){
        //num++; //不是一个原子性操作
        num.getAndIncrement();
    }

    public static void main(String[] args) {

        //理论上num结果应该为2万
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        while (Thread.activeCount()>2){
            Thread.yield();
        }

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

这些类的底层都直接和操作系统挂钩！在内存中修改值！Unsafe类是一个很特殊的存在。

指令重排

什么是指令重排：你写的程序，计算机并不是按照你写的那样去执行的。

源代码–》编译器优化的重排–》指令并行也可能重排–》内存系统也会重排–》执行

处理器在进行指令重排的时候，要考虑一下数据之间的依赖性

volatile 可以避免指令重排

内存屏障，CPU指令。作用：
1、保证特定的操作的执行顺序！
2、可以保证某些变量的内存可见性（利用这些特性volatile 实现了可见性）

volatile 是可以保证可见性。不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生

问：内存屏障在哪个地方使用的最多？
单例模式

19、单例模式

饿汉式

//饿汉式单例
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;
    }
}

DCL懒汉式

package com.slime.single;

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

public class LazyMan {

    private static boolean hanhan = false;

    private LazyMan(){
        synchronized (LazyMan.class){
            if (hanhan == false) {
                hanhan = true;
            }else {
                throw new RuntimeException("不要试图使用反射破坏异常");
            }
        }
    }

    private static LazyMan lazyMan;

    //双重检测锁模式的懒汉式单例，DCL懒汉式
    public static LazyMan getInstance(){
        if (lazyMan == null){
            synchronized (LazyMan.class){
                if (lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }

    //反射
    public static void main(String[] args) throws Exception {
        //LazyMan instance = LazyMan.getInstance();

        Field hanhan = LazyMan.class.getDeclaredField("hanhan");
        hanhan.setAccessible(true);

        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);

        LazyMan instance = declaredConstructor.newInstance();

        hanhan.set(instance,false);

        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance2);
    }

    /*
    * 1、分配内存空间
    * 2、执行构造方法，初始化对象
    * 3、把这个对象指向这个空间
    */

}

静态内部类

package com.slime.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.slime.single;

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

//enum是一个什么？本身也是一个Class类
public enum  EnumSingle {

    INSTANCE;

   public EnumSingle getInstance(){
       return INSTANCE;
   }
}

class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2= declaredConstructor.newInstance();

        System.out.println(instance1);
        System.out.println(instance2);
    }
}

20、深入理解CAS

什么是CAS

public class CASDemo {

    //CAS compareAndSet: 比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);

        //期望、更新
        //public final boolean compareAndSet(int expect,int update)
        //如果我期望的值达到了，那么就更新，否则，就不更新
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());

        atomicInteger.getAndIncrement();
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
    }
}

Unsafe

CAS：比较当前工作内存中的值和主内存的值，如果这个值是期望的，那么则执行操作，如果不是就一直循环。

缺点：
1、循环会耗时
2、一次性只能保证一个共享变量的原子性
3、ABA问题

CBA问题：

public class CASDemo {

    //CAS compareAndSet: 比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);

        //期望、更新
        //public final boolean compareAndSet(int expect,int update)
        //如果我期望的值达到了，那么就更新，否则，就不更新
        //================捣乱的线程====================
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(2021, 2020));
        System.out.println(atomicInteger.get());

        //=================期望的线程============================
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
    }
}

21、原子引用

带版本号的原子操作

package com.slime.cas;

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

public class CASDemo {

    //CAS compareAndSet: 比较并交换
    public static void main(String[] args) {
        AtomicStampedReference<Integer> atomicInteger = new AtomicStampedReference<>(1,1);

        new Thread(()->{
            int stamp = atomicInteger.getStamp();//获得版本号
            System.out.println("al=>"+stamp);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicInteger.compareAndSet(1, 2,
                    atomicInteger.getStamp(), atomicInteger.getStamp() + 1));

            System.out.println("a2=>"+ atomicInteger.getStamp());

            System.out.println(atomicInteger.compareAndSet(2, 1,
                    atomicInteger.getStamp(), atomicInteger.getStamp() + 1));

            System.out.println("a3=>"+ atomicInteger.getStamp());

        },"a").start();

        new Thread(()->{
            int stamp = atomicInteger.getStamp();
            System.out.println("b1=>"+stamp);

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

            System.out.println(atomicInteger.compareAndSet(1, 2,
                    stamp, stamp + 1));

            System.out.println("b=>"+stamp);

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

22、各种锁的理解

22.1、公平锁、非公平锁

公平锁：非常公平，不能够插队，必须先来后到
非公平锁：非常不公平，可以插队（默认都是非公平）

public ReentrantLock() {
        sync = new NonfairSync();
    }

public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

22.2、可重入锁

可重入锁（递归锁）

拿到了外面的锁之后，就可以拿到里面的锁，自动获得。

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版

public class Demo02 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();

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

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

class Phone2{

    Lock lock = new ReentrantLock();

    public void sms(){
        lock.lock();

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

    public void call(){
        lock.lock();

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

22.3、自旋锁

我们自定义一个锁测试

public class SpinlockDemo {

    AtomicReference<Thread> 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);
    }
}

测试

public class TestSpinLock {
    public static void main(String[] args) throws InterruptedException {
        //底层使用的自旋锁CAS
        SpinlockDemo lock = new SpinlockDemo();

        new Thread(()->{
            lock.myLock();

            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.myUnLock();
            }
        },"T1").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            lock.myLock();

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.myUnLock();
            }
        },"T2").start();
    }
}

结果：

22.4、死锁

死锁是什么？

死锁测试，怎排除死锁：

package com.slime.lock;

import java.util.concurrent.TimeUnit;

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

        String lockA = "lockA";
        String lockB = "lockB";

        new Thread(new MyThread(lockA,lockB),"T1").start();
        new Thread(new MyThread(lockB,lockA),"T1").start();
    }
}

class MyThread implements Runnable{

    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA){
            System.out.println(Thread.currentThread().getName()+"lock:"+lockA+"=>get"+lockB);

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

            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+"lock:"+lockB+"=>get"+lockA);
            }
        }
    }
}

结果：

你可能感兴趣的:(JUC并发编程(多线程进阶))

第四天旅游线路预览——从换乘中心到喀纳斯湖陟彼高冈yu 基于Google earth studio 的旅游规划和预览旅游
第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
Goolge earth studio 进阶4——路径修改与平滑陟彼高冈yu Google earth studio 进阶教程旅游
如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
多线程之——ExecutorCompletionService 阿福德
在我们开发中，经常会遇到这种情况，我们起多个线程来执行，等所有的线程都执行完成后，我们需要得到个线程的执行结果来进行聚合处理。我在内部代码评审时，发现了不少这种情况。看很多同学都使用正确，但比较啰嗦，效率也不高。本文介绍一个简单处理这种情况的方法：直接上代码：publicclassExecutorCompletionServiceTest{@TestpublicvoidtestExecutorCo
python多线程程序设计之一 IT_Beijing_BIT #Python 程序设计语言 python
python多线程程序设计之一全局解释器锁线程APIsthreading.active_count()threading.current_thread()threading.excepthook(args,/)threading.get_native_id()threading.main_thread()threading.stack_size([size])线程对象成员函数构造器start/ru
2023-08-20 圆梦菌
魔力宝贝最详细新手教程，新手该如何完美开局，建议收藏转发2023-08-2010:34《魔力宝贝》手游体力是什么?魔力宝贝体力恢复机制是每10分钟回复1点；体力作用：挑战关卡需消耗体力体力获取方式1、好友每天可以赠送15次，也就是15点体力2、系统每天中午12点以及下午6点赠送25体3、在商城使用神石购买《魔力宝贝》手游战斗力如何提升?1、宠物强化宠物通过融合进阶后可以大幅度提升战力，最高级的宠物
Python多线程实现大规模数据集高效转移 sand&wich 网络 python 服务器
背景在处理大规模数据集时，通常需要在不同存储设备、不同服务器或文件夹之间高效地传输数据。如果采用单线程传输方式，当数据量非常大时，整个过程会非常耗时。因此，通过多线程并行处理可以大幅提升数据传输效率。本文将分享一个基于Python多线程实现的高效数据传输工具，通过遍历源文件夹中的所有文件，将它们移动到目标文件夹。工具和库这个数据集转移工具主要依赖于以下Python标准库：os：用于文件系统操作，如
Python实现下载当前年份的谷歌影像 sand&wich python 开发语言
在GIS项目和地图应用中，获取最新的地理影像数据是非常重要的。本文将介绍如何使用Python代码从Google地图自动下载当前年份的影像数据，并将其保存为高分辨率的TIFF格式文件。这个过程涉及地理坐标转换、多线程下载和图像处理。关键功能该脚本的核心功能包括：坐标转换：支持WGS-84与WebMercator投影之间转换，以及处理中国GCJ-02偏移。自动化下载：多线程下载地图瓦片，提高效率。图像
258-各位相加不胖二十斤不改名zz
给定一个非负整数num，反复将各个位上的数字相加，直到结果为一位数。输入:38输出:2解释:各位相加的过程为：3+8=11,1+1=2。由于2是一位数，所以返回2。最简单的方法就是递归了。进阶:你可以不使用循环或者递归，且在O(1)时间复杂度内解决这个问题吗？假如一个三位数'abc'，其值大小为s1=100*a+10*b+1*c，经过一次各位相加后，变为s2=a+b+c，减小的差值为(s1-s2)
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java 开发语言
文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
Python编程 - 函数进阶易辰君 Python核心编程 python 开发语言
目录前言一、函数参数的高级用法（一）缺省参数（二）命名参数（三）不定长参数二、拆包（一）函数返回值拆包（二）通过星号拆包（三）总结三、匿名函数（一）函数定义（二）使用匿名函数四、递归函数（一）简介（二）基本结构（三）简单示例（四）优缺点总结前言上篇文章主要了解了函数基础，如何定义函数，函数种类以及局部变量和全局变量的差异等，接下来就讲解python函数较为进阶的知识点，若有任何想法欢迎一起沟通讨论
教师资格证常考的5个知识点 a3cb74a20840
知识点1：教育与人的发展(5规律、4因素、3动因)五大规律：顺序性—循序渐进阶段性—不搞“一刀切”不平衡性—抓关键期互补性—扬长避短个别差异性—因材施教考点精华：1.举例子对应五大规律;2.每个规律的教学启示;3规律特点。四大因素：遗传(地位：物质前提、可能性)环境(地位：多种可能、现实性)学校教育(主导)个人主观能动性(动力、决定)三大动因：内发论(1.孟子：性善论;2.弗洛伊德：性本能)外铄论
PCIe进阶之TL：Memory, I/O, and Configuration Request Rules & TPH Rules 芯芯之火，可以燎原 PCIe进阶 PCIe进阶硬件工程信息与通信
1Memory,I/O,andConfigurationRequestRules下述规则适用于Memory请求、IO请求和配置请求。除了公共的header字段外，所有Memory请求、IO请求和配置请求还包括以下字段：（1）RequesterID[15:0]和Tag[9:0]，组成了TransactionID。（2）LastDWBE[3:0]和1stDWBE[3:0]字段。对于TH字段置1的Mem
C# 开发教程-入门基础天马3798 教程系列整理 c#开发语言
1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
[面试高频问题]关于多线程的单例模式朱玥玥要每天学习 java 单例模式开发语言
单例模式什么是设计模式?设计模式可以看做为框架或者是围棋中的”棋谱”,红方当头炮,黑方马来跳.根据一些固定的套路下,能保证局势不会吃亏.在日常的程序设计中,往往有许多业务场景,根据这些场景,大佬们总结出了一些固定的套路.按照这个套路来实现代码,也不会吃亏.什么是单例模式,保证某类在程序中只有一个实例,而不会创建多份实例.单例模式具体的实现方式:可分为”懒汉模式”,”饿汉模式”.饿汉模式类加载的同时
后端开发刷题 | 最长回文子串 jingling555 笔试题目 java 算法 javascript 数据结构后端
描述对于长度为n的一个字符串A（仅包含数字，大小写英文字母），请设计一个高效算法，计算其中最长回文子串的长度。数据范围：1≤n≤1000要求：空间复杂度O(1)，时间复杂度O(n2)进阶:空间复杂度O(n)，时间复杂度O(n)示例1输入："ababc"返回值：3说明：最长的回文子串为"aba"与"bab"，长度都为3示例2输入："abbba"返回值：5示例3输入："b"返回值：1思路分析：该题可以
基于flask做大模型SSE输出 Mark_Aussie nlp flask python 后端
默认情况下，Fask以多线程模式运行，每个请求都落在一个新线程上。SSE：基于HTTP的协议，用于实现服务器向客户端推送实时数据。使用长轮询机制，客户端通过HTTP连接向服务器发送请求，并保持该连接打开，服务器可以随时向客户端推送新的数据。SSE协议使用简单的文本格式，数据通过纯文本的消息流进行传输，每个消息以"data:"开头，以两个换行符"\n\n"结尾，如果传递的数据中有字典要使用变量传递。
为什么Node.js不适合CPU密集型应用？ weixin_54503231 node.js
Node.js不适合CPU密集型应用的原因主要基于其设计理念和核心特性，具体可以归纳为以下几点：单线程模型Node.js采用单线程模型来处理用户请求和异步I/O操作。虽然这种模型在处理高并发I/O密集型任务时非常高效，因为它避免了传统多线程模型中的线程上下文切换开销，但这也意味着它不能充分利用现代多核CPU的计算能力。对于需要大量计算资源的CPU密集型应用，单线程模型会成为瓶颈，导致应用性能受限。
PCIe进阶之TL：Common Packet Header Fields & TLPs with Data Payloads Rules 芯芯之火，可以燎原 PCIe进阶 PCIe进阶硬件工程信息与通信
1TransactionLayerProtocol-PacketDefinitionTLP有四种事务类型：Memory、I/O、Configuration和Messages，两种地址格式：32bit和64bit。构成TLP时，所有标记为Reserved的字段（有时缩写为R）都必须全为0。接收者Rx必须忽略此字段中的值，PCIeSwitch必须对其进行原封不动的转发。请注意，对于某些字段，既有指定值
抖音小黄车怎么开？抖音小黄车开通方法？日常购物技巧呀
抖音不仅可以刷短视频，用户还可以在抖音上卖商品，开通小黄车之后就可以卖商品啦，开通小黄车之前，需要申请开通商品橱窗功能；首先打开【抖音短视频】，点开界面右上角的【搜索图标】，搜索【电商小助手】，点击【电商小助手】；选中关注旁边的【私信】，选择界面下方的【申请入口】，点击【商品分享权限】，满足【实名认证】、【进阶要求】之后，选择界面下方的【立即申请】即可；开通商品橱窗之后，就可以挂小黄车啦，方法是不
ROM修改进阶教程------如何修改固件线刷转卡刷卡刷转线刷操作中的一些注意事项安卓机器 ROM修改进阶教程卡刷转换线刷线刷转换卡刷固件转换
在接待各种rom定制化服务中。有很多客户需要各种各样的需求。包括修改rom默认开启usb调试类默认开启开发者选项。修改不锁屏不休眠跳过开机引导以及一些内置app和可卸载app等等的定制项目。还有很多导出系统导出数据完整恢复类要求。今天给大家解析下如何将固件转换类的相关步骤解析通过博文可以了解;1--------线刷固件转换卡刷固件的注意事项以及步骤2--------卡刷固件转换线刷固件的注意事项以
PCL 点云视窗类CloudViewer LeonDL168 PCL 算法计算机视觉人工智能视觉检测图像处理
点云视窗类CloudViewer是简单显示点云的可视化工具类，可以让用户用尽可能少的代码查看点云。注意：点云视窗类不能应用于多线程应用程序中。简单点云可视化如果用户想用几行代码可视化程序中所对应的地物，可以使用下面的代码：#include//...voidfoo(){pcl::PointCloud::Ptrcloud;//...为cloud添加对应的场景pcl::visualization::Cl
爱的进阶懒方的羊
热恋时，你侬我侬。每一刻都不嫌多，最怕时间突然消逝，很多的呢喃还未说道。那简简单单的对望，都显得情深义重。真真是应了那句，有情饮水饱！不满时，锱铢必较。哪怕没有及时的回应，都显得漠不关心，不禁质疑，爱还在么？还有多少？是否已经厌倦？那忙碌的回答，又是否是不在意的敷衍？争吵是，互相伤害。开始彼此埋怨，陈年往事不停地诉说。开始觉得彼此都不愿付出了，却没发现彼此都在不停地索取。这时，两个人是不是在彼此的
互联网 Java 工程师面试题（Java 面试题四）苹果酱0567 面试题汇总与解析 java 中间件开发语言 spring boot 后端
下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
《Android进阶之光》读书笔记 soleil雪寂读书笔记 #Android进阶之光
文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
《Android进阶之光》— Android 书籍王睿丶 Android 永无止境《Android进阶之光》Android书籍 Android phoenix 移动开发
文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
《android进阶之光》——多线程编程（上） TAING要一直努力读书笔记
今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
继续探索通往桃花源的路-我为何参加进阶写作特训营安晴兰
记得一个月前写了一篇为何参加21天爱上写作训练营，我开始了这个写作的旅程。一个月后写了一篇参与课程的心得。我发现这段很短的时间，21天，回首一望，其实，自己才迈开了一步。老师给我们一些方法与技巧，告诉我们补给的重要，老师看着我们继续前行，因为这条写作路，是自己的选择。我相信老师一定希望我们勇往直前，笔从心的继续写下去，做个终生的写作者。这段时间我的写作产出量的确比不上其他多产的小伙伴，但我已达到老
android进阶之光！Android面试必备的集合源码详解，系列篇程序员Sunbu 程序员 Android
前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
桌面上有多个球在同时运动，怎么实现球之间不交叉，即碰撞？换个号韩国红果果 html 小球碰撞
稍微想了一下，然后解决了很多bug，最后终于把它实现了。其实原理很简单。在每改变一个小球的x y坐标后，遍历整个在dom树中的其他小球，看一下它们与当前小球的距离是否小于球半径的两倍？若小于说明下一次绘制该小球（设为a）前要把他的方向变为原来相反方向（与a要碰撞的小球设为b），即假如当前小球的距离小于球半径的两倍的话，马上改变当前小球方向。那么下一次绘制也是先绘制b，再绘制a，由于a的方向已经改变
《高性能HTML5》读后整理的Web性能优化内容白糖_ html5
读后感先说说《高性能HTML5》这本书的读后感吧，个人觉得这本书前两章跟书的标题完全搭不上关系，或者说只能算是讲解了“高性能”这三个字，HTML5完全不见踪影。个人觉得作者应该首先把HTML5的大菜拿出来讲一讲，再去分析性能优化的内容，这样才会有吸引力。因为只是在线试读，没有机会看后面的内容，所以不胡乱评价了。
[JShop]Spring MVC的RequestContextHolder使用误区 dinguangx jeeshop 商城系统 jshop 电商系统
在spring mvc中，为了随时都能取到当前请求的request对象，可以通过RequestContextHolder的静态方法getRequestAttributes()获取Request相关的变量，如request, response等。在jshop中，对RequestContextHolder的
算法之时间复杂度周凡杨 java 算法时间复杂度效率
在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。这是一个关于代表算法输入值的字符串的长度的函数。时间复杂度常用大O符号表述，不包括这个函数的低阶项和首项系数。使用这种方式时，时间复杂度可被称为是渐近的，它考察当输入值大小趋近无穷时的情况。这样用大写O()来体现算法时间复杂度的记法，
Java事务处理 g21121 java
一、什么是Java事务通常的观念认为，事务仅与数据库相关。事务必须服从ISO/IEC所制定的ACID原则。ACID是原子性（atomicity）、一致性（consistency）、隔离性（isolation）和持久性（durability）的缩写。事务的原子性表示事务执行过程中的任何失败都将导致事务所做的任何修改失效。一致性表示当事务执行失败时，所有被该事务影响的数据都应该恢复到事务执行前的状
Linux awk命令详解 510888780 linux
一. AWK 说明 awk是一种编程语言，用于在linux/unix下对文本和数据进行处理。数据可以来自标准输入、一个或多个文件，或其它命令的输出。它支持用户自定义函数和动态正则表达式等先进功能，是linux/unix下的一个强大编程工具。它在命令行中使用，但更多是作为脚本来使用。 awk的处理文本和数据的方式：它逐行扫描文件，从第一行到
android permission 布衣凌宇 Permission
<uses-permission android:name="android.permission.ACCESS_CHECKIN_PROPERTIES" ></uses-permission>允许读写访问"properties"表在checkin数据库中，改值可以修改上传 <uses-permission android:na
Oracle和谷歌Java Android官司将推迟 aijuans java oracle
北京时间 10 月 7 日，据国外媒体报道，Oracle 和谷歌之间一场等待已久的官司可能会推迟至 10 月 17 日以后进行，这场官司的内容是 Android 操作系统所谓的 Java 专利权之争。本案法官 William Alsup 称根据专利权专家 Florian Mueller 的预测，谷歌 Oracle 案很可能会被推迟。　　该案中的第二波辩护被安排在 10 月 17 日出庭，从目前看来
linux shell 常用命令 antlove linux shell command
grep [options] [regex] [files] /var/root # grep -n "o" * hello.c:1:/* This C source can be compiled with:
Java解析XML配置数据库连接(DOM技术连接 SAX技术连接) 百合不是茶 sax技术 Java解析xml文档 dom技术 XML配置数据库连接
XML配置数据库文件的连接其实是个很简单的问题,为什么到现在才写出来主要是昨天在网上看了别人写的,然后一直陷入其中,最后发现不能自拔所以今天决定自己完成 ,,,,现将代码与思路贴出来供大家一起学习 XML配置数据库的连接主要技术点的博客; JDBC编程 : JDBC连接数据库 DOM解析XML: DOM解析XML文件 SA
underscore.js 学习（二） bijian1013 JavaScript underscore
Array Functions 所有数组函数对参数对象一样适用。1.first _.first(array, [n]) 别名: head, take 返回array的第一个元素，设置了参数n，就
plSql介绍 bijian1013 oracle 数据库 plsql
/* * PL/SQL 程序设计学习笔记 * 学习plSql介绍.pdf * 时间：2010-10-05 */ --创建DEPT表 create table DEPT ( DEPTNO NUMBER(10), DNAME NVARCHAR2(255), LOC NVARCHAR2(255) ) delete dept; select
【Nginx一】Nginx安装与总体介绍 bit1129 nginx
启动、停止、重新加载Nginx nginx 启动Nginx服务器，不需要任何参数u nginx -s stop 快速(强制)关系Nginx服务器 nginx -s quit 优雅的关闭Nginx服务器 nginx -s reload 重新加载Nginx服务器的配置文件 nginx -s reopen 重新打开Nginx日志文件
spring mvc开发中浏览器兼容的奇怪问题 bitray jquery Ajax springMVC 浏览器上传文件
最近个人开发一个小的OA项目,属于复习阶段.使用的技术主要是spring mvc作为前端框架,mybatis作为数据库持久化技术.前台使用jquery和一些jquery的插件. 在开发到中间阶段时候发现自己好像忽略了一个小问题,整个项目一直在firefox下测试,没有在IE下测试,不确定是否会出现兼容问题.由于jquer
Lua的io库函数列表 ronin47 lua io
1、io表调用方式：使用io表，io.open将返回指定文件的描述，并且所有的操作将围绕这个文件描述　　io表同样提供三种预定义的文件描述io.stdin,io.stdout,io.stderr 　　2、文件句柄直接调用方式,即使用file:XXX()函数方式进行操作,其中file为io.open()返回的文件句柄　　多数I/O函数调用失败时返回nil加错误信息,有些函数成功时返回nil
java-26-左旋转字符串 bylijinnan java
public class LeftRotateString { /** * Q 26 左旋转字符串 * 题目：定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部。 * 如把字符串abcdef左旋转2位得到字符串cdefab。 * 请实现字符串左旋转的函数。要求时间对长度为n的字符串操作的复杂度为O(n)，辅助内存为O(1)。 */ pu
《vi中的替换艺术》-linux命令五分钟系列之十一 cfyme linux命令
vi方面的内容不知道分类到哪里好，就放到《Linux命令五分钟系列》里吧！今天编程，关于栈的一个小例子，其间我需要把”S.”替换为”S->”(替换不包括双引号)。其实这个不难，不过我觉得应该总结一下vi里的替换技术了，以备以后查阅。 1 所有替换方案都要在冒号“:”状态下书写。 2 如果想将abc替换为xyz，那么就这样 :s/abc/xyz/ 不过要特别
[轨道与计算]新的并行计算架构 comsci 并行计算
我在进行流程引擎循环反馈试验的过程中，发现一个有趣的事情。。。如果我们在流程图的每个节点中嵌入一个双向循环代码段，而整个流程中又充满着很多并行路由，每个并行路由中又包含着一些并行节点，那么当整个流程图开始循环反馈过程的时候，这个流程图的运行过程是否变成一个并行计算的架构呢？
重复执行某段代码 dai_lm android
用handler就可以了 private Handler handler = new Handler(); private Runnable runnable = new Runnable() { public void run() { update(); handler.postDelayed(this, 5000); } }; 开始计时 h
Java实现堆栈（list实现） datageek 数据结构——堆栈
public interface IStack<T> { //元素出栈，并返回出栈元素 public T pop(); //元素入栈 public void push(T element); //获取栈顶元素 public T peek(); //判断栈是否为空 public boolean isEmpty
四大备份MySql数据库方法及可能遇到的问题 dcj3sjt126com DB backup
一：通过备份王等软件进行备份前台进不去？用备份王等软件进行备份是大多老站长的选择，这种方法方便快捷，只要上传备份软件到空间一步步操作就可以，但是许多刚接触备份王软件的客用户来说还原后会出现一个问题：因为新老空间数据库用户名和密码不统一，网站文件打包过来后因没有修改连接文件，还原数据库是好了，可是前台会提示数据库连接错误，网站从而出现打不开的情况。解决方法：学会修改网站配置文件，大多是由co
github做webhooks：[1]钩子触发是否成功测试 dcj3sjt126com github git webhook
转自: http://jingyan.baidu.com/article/5d6edee228c88899ebdeec47.html github和svn一样有钩子的功能，而且更加强大。例如我做的是最常见的push操作触发的钩子操作，则每次更新之后的钩子操作记录都会在github的控制板可以看到！工具/原料 github 方法/步骤
">的作用" target="_blank">JSP中的作用蕃薯耀
JSP中<base href="<%=basePath%>">的作用 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
linux下SAMBA服务安装与配置 hanqunfeng linux
局域网使用的文件共享服务。一.安装包： rpm -qa | grep samba samba-3.6.9-151.el6.x86_64 samba-common-3.6.9-151.el6.x86_64 samba-winbind-3.6.9-151.el6.x86_64 samba-client-3.6.9-151.el6.x86_64 samba-winbind-clients
guava cache IXHONG cache
缓存，在我们日常开发中是必不可少的一种解决性能问题的方法。简单的说，cache 就是为了提升系统性能而开辟的一块内存空间。　　缓存的主要作用是暂时在内存中保存业务系统的数据处理结果，并且等待下次访问使用。在日常开发的很多场合，由于受限于硬盘IO的性能或者我们自身业务系统的数据处理和获取可能非常费时，当我们发现我们的系统这个数据请求量很大的时候，频繁的IO和频繁的逻辑处理会导致硬盘和CPU资源的
Query的开始--全局变量,noconflict和兼容各种js的初始化方法 kvhur JavaScript jquery css
这个是整个jQuery代码的开始，里面包含了对不同环境的js进行的处理，例如普通环境，Nodejs，和requiredJs的处理方法。还有jQuery生成$, jQuery全局变量的代码和noConflict代码详解完整资源： http://www.gbtags.com/gb/share/5640.htm jQuery 源码： (
美国人的福利和中国人的储蓄 nannan408
今天看了篇文章，震动很大，说的是美国的福利。美国医院的无偿入院真的是个好措施。小小的改善，对于社会是大大的信心。小孩，税费等，政府不收反补，真的体现了人文主义。美国这么高的社会保障会不会使人变懒？答案是否定的。正因为政府解决了后顾之忧，人们才得以倾尽精力去做一些有创造力，更造福社会的事情，这竟成了美国社会思想、人
N阶行列式计算(JAVA) qiuwanchi N阶行列式计算
package gaodai; import java.util.List; /** * N阶行列式计算 * @author 邱万迟 * */ public class DeterminantCalculation { public DeterminantCalculation(List<List<Double>> determina
C语言算法之打渔晒网问题 qiufeihu c 算法
如果一个渔夫从2011年1月1日开始每三天打一次渔，两天晒一次网，编程实现当输入2011年1月1日以后任意一天，输出该渔夫是在打渔还是在晒网。代码如下： #include <stdio.h> int leap(int a) /*自定义函数leap()用来指定输入的年份是否为闰年*/ { if((a%4 == 0 && a%100 != 0
XML中DOCTYPE字段的解析 wyzuomumu xml
DTD声明始终以!DOCTYPE开头,空一格后跟着文档根元素的名称,如果是内部DTD,则再空一格出现[],在中括号中是文档类型定义的内容. 而对于外部DTD,则又分为私有DTD与公共DTD,私有DTD使用SYSTEM表示,接着是外部DTD的URL. 而公共DTD则使用PUBLIC,接着是DTD公共名称,接着是DTD的URL. 私有DTD <!DOCTYPErootSYST

JUC并发编程(多线程进阶)

目录

1、什么是JUC

2、线程和进程

3、Lock锁（重点）

4、生产者和消费者的问题

5、Condition

6、八锁现象

7、集合类不安全

8、Callable

9、常用的辅助类

9.1、CountDownLatch

9.2、CyclicBarrier

9.3、Semaphore

10、读写锁

11、阻塞队列

11.1、四组API

11.2、SynchronousQueue 同步队列

12、 线程池

13、四大函数式接口

14、Stream流式计算

15、ForkJoin

16、异步回调

17、JMM

18、volatile

19、单例模式

20、深入理解CAS

21、原子引用

22、各种锁的理解

22.1、公平锁、非公平锁

22.2、可重入锁

22.3、自旋锁

22.4、死锁

你可能感兴趣的:(JUC并发编程(多线程进阶))

12、线程池