hzp666
hzp666

Java中Juc并发编程基础

1. 什么是JUC

就是java.util.concurrent并发包下面使用的工具包

1.1 线程和进程

进程: 是一个程序,QQ.exe,网易云音乐 ,大数据领域的NameNode其实就是程序的集合,一个进程往往可以包含多个线程,至少包含一个线程!

那么我们的Java默认有几个线程呢? main 和 gc线程

线程:  例如我们的360我们可以进行杀毒期间也可以进行清理数据

Java 真的可以开启线程吗 ? 开不了,线程是本地方法来负责开启的

并行和并发

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

  • CPU单核,模拟出来多线程,快速交替

并行: 多个人一起行走

  • CPU多核,多个线程可以同时运行

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

1.2 多线程

如有需要请看我博客

https://blog.csdn.net/weixin_43704599/article/details/107379994

2. Lock锁

2.1 synchronized

synchronized

package com.bigdata.juc.demo01;

/**
* Copyright (c) 2020 bigdata ALL Rights Reserved
* Project: learning
* Package: com.bigdata.juc.demo01
* Version: 1.0
* 真正的多线程开发,公司的开发
* 线程就是一个单独的资源类,没有任何附属的操作
* 1. 属性,方法
*
* @author qingzhi.wu 2020/7/16 17:21
*/
public class SaleTicketDemo01 {
   public static void main(String[] args) {
       //并发:多线程操作同一个资源类
       Ticket ticket = new Ticket();
       new Thread(() -> {
           for (int i = 0; i < 40; i++) {

               ticket.sale();


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

       new Thread(() -> {
           for (int i = 0; i < 40; i++) {

               ticket.sale();


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

       new Thread(() -> {
           for (int i = 0; i < 40; i++) {

               ticket.sale();


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

//资源类 OOP
class Ticket {

   //属性,方法
   private int number = 30;

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

2.2 RentrantLock

公平锁: 十分公平,先来后到

非公平锁: 十分不公平,可以插队(默认)

//并发:多线程操作同一个资源类
       Ticket ticket = new Ticket();
       new Thread(() -> {
           for (int i = 0; i < 40; i++) {

               ticket.sale();


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

       new Thread(() -> {
           for (int i = 0; i < 40; i++) {

               ticket.sale();


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

       new Thread(() -> {
           for (int i = 0; i < 40; i++) {

               ticket.sale();


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

2.3 synchronized 和 lock 的区别

  1. synchronized  是一个内置的Java关键字,Lock是一个java类

  2. synchronized  无法判断获取锁的状态,Lock 可以判断是否获取到了锁

  3. synchronized  会自动释放锁,Lock 必须要手动释放锁!如果不释放锁,死锁

  4. synchronized  线程1(获得锁,阻塞) 线程2 (等待,傻傻的等) Lock锁就不一定会傻傻的等了

  5. synchronized  可重入锁,不可以中断的,非公平;Lock ,可重入锁,可以判断锁,非公平(可以自己设置)

  6. synchronized  适合锁少量的代码同步问题,Lock 适合锁大量的同步代码!

3. 生产者和消费者问题

3.1 生产者和消费者问题 synchronized 版本

package com.bigdata.juc.pc;

/**
* Copyright (c) 2019 bigdata ALL Rights Reserved
* Project: learning
* Package: com.bigdata.juc.pc
* Version: 1.0
* 线程之间的通信问题
* 线程交替执行
* 等待唤醒,通知唤醒
* A B 线程 操作同一个变量 num = 0
* A num +1
* B num -1
* @author qingzhi.wu 2020/7/16 20:55
*/
public class Test1 {
   public static void main(String[] args) {
       Data data = new Data();

       new Thread(()->{
           for (int i = 0; i < 10; i++) {
               data.increment();
          }

      },"A").start();

       new Thread(()->{
           for (int i = 0; i < 10; i++) {
               data.decrement();
          }

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

//判断等待,业务,通知
//资源类
class Data {
   private int number = 0;
   //+1
   public synchronized void  increment(){
       if (number != 0){
           try {
               this.wait();
          } catch (InterruptedException e) {
               e.printStackTrace();
          }
      }
       number++;
       System.out.println(Thread.currentThread().getName()+"=>"+number);
       //通知其他线程,我+1完毕了
       this.notifyAll();
  }
   //-1
   public synchronized void  decrement(){
       if (number == 0){
           //等待
           try {
               this.wait();
          } catch (InterruptedException e) {
               e.printStackTrace();
          }
      }
       number--;
       System.out.println(Thread.currentThread().getName()+"=>"+number);
       // 通知其他线程 ,我 -1 完毕了
       this.notifyAll();
  }
}

问题存在,A B C D 4个线程怎么办,改为while循环就好了-- 虚假唤醒问题

https://www.cnblogs.com/tqyysm/articles/9765667.html

package com.bigdata.juc.pc;

/**
* Copyright (c) 2019 bigdata ALL Rights Reserved
* Project: learning
* Package: com.bigdata.juc.pc
* Version: 1.0
* 线程之间的通信问题
* 线程交替执行
* 等待唤醒,通知唤醒
* A B 线程 操作同一个变量 num = 0
* A num +1
* B num -1
* @author qingzhi.wu 2020/7/16 20:55
*/
public class Test1 {
   public static void main(String[] args) {
       Data data = new Data();

       new Thread(()->{
           for (int i = 0; i < 10; i++) {
               data.increment();
          }

      },"A").start();

       new Thread(()->{
           for (int i = 0; i < 10; i++) {
               data.decrement();
          }

      },"B").start();

       new Thread(()->{
           for (int i = 0; i < 10; i++) {
               data.increment();
          }

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

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

//判断等待,业务,通知
//资源类
class Data {
   private int number = 0;
   //+1
   public synchronized void  increment(){
       while (number != 0){
           try {
               this.wait();
          } catch (InterruptedException e) {
               e.printStackTrace();
          }
      }
       number++;
       System.out.println(Thread.currentThread().getName()+"=>"+number);
       //通知其他线程,我+1完毕了
       this.notifyAll();
  }
   //-1
   public synchronized void  decrement(){
       while (number == 0){
           //等待
           try {
               this.wait();
          } catch (InterruptedException e) {
               e.printStackTrace();
          }
      }
       number--;
       System.out.println(Thread.currentThread().getName()+"=>"+number);
       // 通知其他线程 ,我 -1 完毕了
       this.notifyAll();
  }
}

3.2 生产者和消费者问题 Lock版本

package com.bigdata.juc.pc;

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

/**
* Copyright (c) 2019 bigdata ALL Rights Reserved
* Project: learning
* Package: com.bigdata.juc.pc
* Version: 1.0
* 线程之间的通信问题
* 线程交替执行
* 等待唤醒,通知唤醒
* A B 线程 操作同一个变量 num = 0
* A num +1
* B num -1
*
* @author qingzhi.wu 2020/7/16 20:55
*/
public class Test2 {
   public static void main(String[] args) {
       Data data = new Data();

       new Thread(() -> {
           for (int i = 0; i < 10; i++) {
               data.increment();
          }

      }, "A").start();

       new Thread(() -> {
           for (int i = 0; i < 10; i++) {
               data.decrement();
          }

      }, "B").start();

       new Thread(() -> {
           for (int i = 0; i < 10; i++) {
               data.increment();
          }

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

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

//判断等待,业务,通知
//资源类
class Data2 {
   Lock lock = new ReentrantLock();
   Condition condition = lock.newCondition();

   private int number = 0;

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

  }

   //-1
   public void decrement() {

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

 

3.3 生产者和消费者问题(精确通知)

package com.bigdata.juc.pc;

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

/**
* Copyright (c) 2019 bigdata ALL Rights Reserved
* Project: learning
* Package: com.bigdata.juc.pc
* Version: 1.0
* 线程之间的通信问题
* 线程交替执行
* 等待唤醒,通知唤醒
* A B 线程 操作同一个变量 num = 0
* A num +1
* B num -1
* A-B-C-A-B
* @author qingzhi.wu 2020/7/16 20:55
*/
public class Test3 {
   public static void main(String[] args) {
       Data3 data = new Data3();

       new Thread(() -> {
           for (; ; ) {
               data.printA();
          }

      }, "A").start();

       new Thread(() -> {
           for (; ; ) {
               data.printB();
          }

      }, "B").start();

       new Thread(() -> {
           for (; ; ) {
               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; //2 3
   public void printA(){
       lock.lock();
       try {
           while (number != 1){
               //等待
               try {
                   condition1.await();
              } catch (InterruptedException e) {
                   e.printStackTrace();
              }
          }
           System.out.println(Thread.currentThread().getName());
           number = 2;
           condition2.signal();
      }finally {
           lock.unlock();
      }
  }
   public void printB(){
       lock.lock();
       try {
           while (number != 2){
               try {
                   condition2.await();
              } catch (InterruptedException e) {
                   e.printStackTrace();
              }
          }
           number ++;
           System.out.println(Thread.currentThread().getName());
           condition3.signal();
      }finally {
           lock.unlock();
      }
  }
   public void printC(){
       lock.lock();
       try {
           while (number != 3){
               try {
                   condition3.await();
              } catch (InterruptedException e) {
                   e.printStackTrace();
              }
          }
           number = 1 ;
           System.out.println(Thread.currentThread().getName());
           condition1.signal();
           condition3.signal();
      }finally {
           lock.unlock();
      }
  }
}

4. 八锁现象

如何判断锁的是谁?

4.1 单对象调用多方法

package com.bigdata.lock8;

import java.util.concurrent.TimeUnit;

/**
* Copyright (c) 2020 bigdata ALL Rights Reserved
* Project: learning
* Package: com.bigdata.lock8
* Version: 1.0
* 1. 标准情况下,两个线程先打印 发短信 还是打电话
* 1 发短信
* 2 打电话
* @author qingzhi.wu 2020/7/17 9:30
*/
public class Test1 {
   public static void main(String[] args) throws InterruptedException {
       //其实 锁的 phone 谁先拿到 就是谁先执行
       Phone phone = new Phone();
       //是因为锁的原因
       new Thread(()->{
           phone.senSms();
      }).start();
       TimeUnit.SECONDS.sleep(1);
       new Thread(()->{
           phone.call();
      }).start();

  }

   static class Phone {
       //synchronized 锁的对象是方法的调用者
       //两个方法用的是同一个锁,谁先拿到谁执行
       public synchronized  void senSms(){
           try {
               TimeUnit.SECONDS.sleep(1);
          } catch (InterruptedException e) {
               e.printStackTrace();
          }
           System.out.println("发短信");
      }

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

锁的是一个对象,两个对象的锁是一样的,所以发短信先执行然后再打电话

4.2 多对象对象调用多方法

package com.bigdata.lock8;

import java.util.concurrent.TimeUnit;

/**
* Copyright (c) 2020 bigdata ALL Rights Reserved
* Project: learning
* Package: com.bigdata.lock8
* Version: 1.0
* 1. 标准情况下,两个线程先打印 发短信 还是打电话
* 1 发短信
* 2 打电话
* @author qingzhi.wu 2020/7/17 9:30
*/
public class Test1 {
   public static void main(String[] args) throws InterruptedException {
       //其实 锁的 phone 谁先拿到 就是谁先执行
       Phone phone = new Phone();
       Phone phone1 = new Phone();
       //是因为锁的原因
       new Thread(()->{
           phone.senSms();
      }).start();
       TimeUnit.SECONDS.sleep(1);
       new Thread(()->{
           phone1.call();
      }).start();

  }

   static class Phone {
       //synchronized 锁的对象是方法的调用者
       //两个方法用的是同一个锁,谁先拿到谁执行
       public synchronized  void senSms(){
           try {
               TimeUnit.SECONDS.sleep(1);
          } catch (InterruptedException e) {
               e.printStackTrace();
          }
           System.out.println("sendsms");
      }

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

因为是new 了两个资源类,所以 锁不是同一个,所以 先 打电话再发短信

4.3 单对象同时调用同步方法和非同步方法

package com.bigdata.lock8;

import java.util.concurrent.TimeUnit;

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.lock8
 * Version: 1.0
 * 1. 标准情况下,两个线程先打印 发短信 还是打电话
 * 1 发短信
 * 2 打电话
 * @author qingzhi.wu 2020/7/17 9:30
 */
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        //其实 锁的 phone  谁先拿到 就是谁先执行
        Phone phone = new Phone();
       // Phone phone1 = new Phone();
        //是因为锁的原因
        new Thread(()->{
            phone.senSms();
        }).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone.hello();
        }).start();

    }

    static class Phone {
        //synchronized 锁的对象是方法的调用者
        //两个方法用的是同一个锁,谁先拿到谁执行
        public synchronized  void senSms(){
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("sendsms");
        }

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

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

肯定是先hello 在发短信,因为 他根本就没锁啊 不需要等待,直接就可以执行

 

4.4 多对象调用同步方法和非同步方法

package com.bigdata.lock8;

import java.util.concurrent.TimeUnit;

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.lock8
 * Version: 1.0
 * 1. 标准情况下,两个线程先打印 发短信 还是打电话
 * 1 发短信
 * 2 打电话
 * @author qingzhi.wu 2020/7/17 9:30
 */
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        //其实 锁的 phone  谁先拿到 就是谁先执行
        Phone phone = new Phone();
        Phone phone1 = new Phone();
        //是因为锁的原因
        new Thread(()->{
            phone.senSms();
        }).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone1.hello();
        }).start();

    }

    static class Phone {
        //synchronized 锁的对象是方法的调用者
        //两个方法用的是同一个锁,谁先拿到谁执行
        public synchronized  void senSms(){
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("sendsms");
        }

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

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

肯定是hello先执行,因为他没有锁,他俩根本就没有关系,发短信还睡了4秒

 

4.5 单对象调用同步和静态同步方法

package com.bigdata.lock8;

import java.util.concurrent.TimeUnit;

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.lock8
 * Version: 1.0
 * 1. 标准情况下,两个线程先打印 发短信 还是打电话
 * 1 发短信
 * 2 打电话
 * @author qingzhi.wu 2020/7/17 9:30
 */
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        //其实 锁的 phone  谁先拿到 就是谁先执行
        Phone phone = new Phone();
        Phone phone1 = new Phone();
        //是因为锁的原因
        new Thread(()->{
            phone.senSms();
        }).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone1.call();
        }).start();

    }

    static class Phone {
        //synchronized 锁的对象是方法的调用者
        //两个方法用的是同一个锁,谁先拿到谁执行
        public synchronized  void senSms(){
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("sendsms");
        }

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

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

先执行的打电话,后执行的发短信,因为静态修饰的同步方法,锁是类的Class模板,同步非静态方法的锁是对象,所以他俩的锁不是一个锁

4.6 单对象调用双静态方法

package com.bigdata.lock8;

import java.util.concurrent.TimeUnit;

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.lock8
 * Version: 1.0
 * 1. 标准情况下,两个线程先打印 发短信 还是打电话
 * 1 发短信
 * 2 打电话
 * @author qingzhi.wu 2020/7/17 9:30
 */
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        //其实 锁的 phone  谁先拿到 就是谁先执行
        Phone phone = new Phone();
        Phone phone1 = new Phone();
        //是因为锁的原因
        new Thread(()->{
            phone.senSms();
        }).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone1.call();
        }).start();

    }

    static class Phone {
        //synchronized 锁的对象是方法的调用者
        //两个方法用的是同一个锁,谁先拿到谁执行
        public static synchronized  void senSms(){
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("sendsms");
        }

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

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

 

肯定是先发短信再打电话,因为他俩的锁的对象是同一个,都是class文件

4.7 双对象调用双静态方法

package com.bigdata.lock8;

import java.util.concurrent.TimeUnit;

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.lock8
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/17 9:49
 */
public class Test4 {

    public static void main(String[] args) throws InterruptedException {
        //其实 锁的 phone  谁先拿到 就是谁先执行
        //两个对象 两个锁
        Phone phone = new Phone();
        Phone phone1 = new Phone();
        //是因为锁的原因
        new Thread(()->{
            phone.senSms();
        }).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone1.call();
        }).start();

    }

    static class Phone {
        //synchronized 锁的对象是方法的调用者
        //两个方法用的是同一个锁,谁先拿到谁执行
        // static 锁的是字节码Class 模板
        public static synchronized  void senSms(){
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("sendsms");
        }

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

 

先发短信,后打电话,因为锁是同一个class字节码文件

5. 集合类

5.1 CopyOnWriteArrayList

package com.bigdata.list;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.list
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/17 10:21
 */
public class ListTest {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }

    }
}

Java中Juc并发编程基础_第1张图片

可以采用Vector解决

package com.bigdata.list;

import java.util.List;
import java.util.UUID;
import java.util.Vector;

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.list
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/17 10:21
 */
public class ListTest {
    public static void main(String[] args) {
        List list = new Vector<>();

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

    }
}

采用Collections.synchronizedList解决

package com.bigdata.list;

import java.util.*;

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.list
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/17 10:21
 */
public class ListTest {
    public static void main(String[] args) {
        List list = Collections.synchronizedList(new ArrayList());

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

    }
}

CopyOnWriteArrayList 解决

package com.bigdata.list;

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

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.list
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/17 10:21
 */
public class ListTest {
    public static void main(String[] args) {
        CopyOnWriteArrayList list = new CopyOnWriteArrayList<>();

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

    }
}

CopyOnWrite 写入时复制 COW 计算机程序设计领域的一种优化策略,多个线程调用的时候,在写入的时候避免覆盖,造成数据问题 读写分离

CopyOnWriteArrayList 比 Vector 效率高很多

Java中Juc并发编程基础_第2张图片

5.2 CopyOnWriteArraySet

HashSet的实现多线程插入

package com.bigdata.list;

import java.util.HashSet;
import java.util.Set;
import java.util.UUID;

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.list
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/17 11:14
 */
public class SetTest {
    public static void main(String[] args) {
        Set list = new HashSet<>();

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

Java中Juc并发编程基础_第3张图片

基于Collections的

package com.bigdata.list;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.list
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/17 11:14
 */
public class SetTest {
    public static void main(String[] args) {
        Set list = Collections.synchronizedSet(new HashSet());

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

CopyOnWriteArraySet

package com.bigdata.list;

import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.list
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/17 11:14
 */
public class SetTest {
    public static void main(String[] args) {
        CopyOnWriteArraySet list = new CopyOnWriteArraySet();

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

5.3 ConcurrentHashMap

常用的HashMap

package com.bigdata.list;

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.list
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/17 11:48
 */
public class MapTest {
    public static void main(String[] args) {
        Map map = new HashMap();

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

    }
}

Java中Juc并发编程基础_第4张图片

ConcurrentHashMap 解决

package com.bigdata.list;

import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.list
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/17 11:48
 */
public class MapTest {
    public static void main(String[] args) {
        ConcurrentHashMap map = new ConcurrentHashMap();

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

    }
}

6. Callable

  1. 可以有返回值

  2. 可以抛出异常

  3. 方法不同,run(),call()

代码测试一下

package com.bigdata.callable;

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

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.callable
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/17 13:12
 */
public class CallableTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask futureTask = new FutureTask<>(new MyThread());

        new Thread(futureTask).start();

        String s = futureTask.get();
        System.out.println(s);
    }
}

class MyThread implements Callable {

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

细节:

  1. 有缓存

  2. 结果可能需要等待,会阻塞

7. 辅助工具类

7.1 CountDownLatch

package com.bigdata.add;

import java.util.concurrent.CountDownLatch;

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.add
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/17 14:45
 */
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        //总数是6
        CountDownLatch countDownLatch = new CountDownLatch(11);
        countDownLatch.countDown(); //-1

        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "Go Out");
                countDownLatch.countDown(); //数量 -1
            },String.valueOf(i)).start();
        }

        countDownLatch.await();

       // countDownLatch.countDown();
        System.out.println("Close Door");
    }
}

  • 等所有线程执行完毕之后 就会执行Close Door

7.2 CyclicBarrier

package com.bigdata.add;

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

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.add
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/17 15:38
 */
public class CycBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("集齐了,七颗龙珠");
        });

        for (int i = 1; i <= 7; i++) {
            int finalI = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"拿到了第"+ finalI + "颗龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

主要用来判断执行了几步了.都执行完成 执行最终线程

7.3 Semaphore (信号量)

package com.bigdata.add;

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

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.add
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/17 16:02
 */
public class SemaphoreTest {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <=6; i++) {
            int finalI = i;
            new Thread(
                    ()->{
                        try {
                            semaphore.acquire();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                        System.out.println(Thread.currentThread().getName()+"->"+ finalI+"进入了车位");
                        try {
                            TimeUnit.SECONDS.sleep(2);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }finally {
                            semaphore.release();
                        }
                        System.out.println(Thread.currentThread().getName()+"->"+ finalI+"离开了车位");

                    }
            ).start();
        }
    }
}

 

用于限流

8. 读写锁

package com.bigdata.add;

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

/**
 * Copyright (c) 2020 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.add
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/17 17:21
 */
public class ReadWriteLock {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        for (int i = 1; i <= 10; i++) {
            int finalI = i;
            new Thread(()->{
                myCache.put(finalI,new Object());

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

        for (int i = 1; i <= 10; i++) {
            int finalI = i;
            new Thread(()->{
                myCache.get(finalI);

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


    }
}
class MyCache {
    private Map data = new HashMap<>();
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void put(Integer key,Object value){
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"开始添加数据");
            data.put(key,value);
            System.out.println(Thread.currentThread().getName()+"添加数据OK");

        } finally {
            lock.writeLock().unlock();
        }
    }


    public void get(Integer key){
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"开始查询数据");
            data.get(key);
            System.out.println(Thread.currentThread().getName()+"查询数据OK");

        } finally {
            lock.readLock().unlock();
        }
    }
}

  • 读--写 互斥

  • 读--读 共享

  • 写--写 互斥

写锁是独占锁,读锁是共享锁

9. 阻塞队列

9.1 BlockingQueue

Java中Juc并发编程基础_第5张图片

 

9.2 四组API

方式 抛出异常 不会抛出异常 阻塞等待 超时等待
添加 add offer put offer
移除 remove poll take poll
判断队列首 element peek - -

抛出异常

    /**
     * 抛出异常
     */
    public 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"));
       //System.out.println(blockingQueue.add("d"));
        //String remove = blockingQueue.remove();
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.element());

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

不抛出异常

    /**
     * 不抛出异常
     */
    public void test2(){
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        System.out.println(blockingQueue.offer("d")); //false
        System.out.println(blockingQueue.element());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll()); //null
    }

阻塞等待

    /**
     * 阻塞等待
     */
    public void test3() throws InterruptedException {
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);
        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");
        blockingQueue.take();
        blockingQueue.take();
        blockingQueue.take();
        blockingQueue.take();
        blockingQueue.put("d");
    }

超时等待

 /**
     * 阻塞等待
     */
    public 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);
        blockingQueue.poll(2,TimeUnit.SECONDS);
        blockingQueue.poll(2,TimeUnit.SECONDS);
        blockingQueue.poll(2,TimeUnit.SECONDS);
        //超过2秒就退出
        blockingQueue.poll(2,TimeUnit.SECONDS); 
//        blockingQueue.take();
//        blockingQueue.take();
//        blockingQueue.take();
//        blockingQueue.take();
//        blockingQueue.put("d");
    }

9.3 SynchronousQueue

package com.bigdata.bq;

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

/**
 * Copyright (c) 2019 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.bq
 * Version: 1.0
 * 同步队列
 * 和其他的blocking queue 不一样SynchronousQueue 不存储元素
 * put了一个元素,必须从里面先take出来 否则不能再put进去值!
 * @author qingzhi.wu 2020/7/18 10:58
 */
public class Test2 {
    public static void main(String[] args) {
        SynchronousQueue synchronousQueue = new SynchronousQueue<>();

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

        ,"T1").start();

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

                ,"T2").start();
    }

}
 
  
10. 线程池
 
  
10.1 线程池简介
 
  
线程池: 三大方法,7大参数,4中拒绝策略
 
  
 
   
池化技术
 
  
 
  
程序的运行,本质: 占用系统的资源!
 
  
线程池,连接池,内存池,对象池..
 
  
池化技术: 事先准备好一些资源,有人要用,就来我这里拿,用完之后还给我
 
  
 
 
  
线程池的好处:
 
  
     
   
  1.  
    降低资源的消耗
     
    2.  
   
  2.  
    提高响应的速度
     
    3.  
   
  3.  
    方便管理
     
    4.  
  
 
  
线程复用,可以控制最大的并发数,管理线程
 
  
Java中Juc并发编程基础_第6张图片
 
  
10.2 三大方法
 
  
package com.bigdata.pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Copyright (c) 2019 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.pool
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/18 11:27
 *
 *
 * Exectors 工具类  3大方法
 * 使用了线程池之后,使用线程池来创建线程
 */
public class Demo01 {
    public static void main(String[] args) {
        // 单个线程
        //ExecutorService executorService = Executors.newSingleThreadExecutor();

//        // 创建一个固定的线程池大小
        ExecutorService threadpool = Executors.newFixedThreadPool(1000);
//        //可伸缩的,遇强则强,遇弱则弱
//        Executors.newCachedThreadPool();

        try {
            for (int i = 0; i < 1000; i++) {

                threadpool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"ok");
                });
            }
        } finally {
            threadpool.shutdown();
        }

    }
}
 
  
10.3 七大参数
 
  
 
   
源码分析
 
  
 
  
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue()));
    }
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue());
    }
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue());
    }

 
  
本质就是ThreadPoolExecutor
 
  
    public ThreadPoolExecutor(int corePoolSize,    //核心线程池大小
                              int maximumPoolSize, //最大线程池大小
                              long keepAliveTime,  //超时了,没有人调用就会释放
                              TimeUnit unit,       //超时单位
                              BlockingQueue workQueue, //阻塞队列
                              ThreadFactory threadFactory,       //线程工厂,创建线程的,一般不用动
                              RejectedExecutionHandler handler   //拒绝策略
                             ) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }
 
  
     
   
  •  
    int corePoolSize                                              核心线程数大小
     
    •  
   
  •  
    int maximumPoolSize                                   最大线程数大小
     
    •  
   
  •  
    long keepAliveTime                                       超时了,没人调用就会被释放
     
    •  
   
  •  
    TimeUnit unit                                                 超时单位
     
    •  
   
  •  
    BlockingQueue workQueue 阻塞队列
     
    •  
   
  •  
    ThreadFactory threadFactory                     线程工厂,创建线程的,一般不用动
     
    •  
   
  •  
    RejectedExecutionHandler handler          拒绝策略
     
    •  
  
 
  
Java中Juc并发编程基础_第7张图片
 
  
Java中Juc并发编程基础_第8张图片
 
  
 
   
手动创建线程池
 
  
 
  
 
 
  
10.4 四种拒绝策略
 
  
Java中Juc并发编程基础_第9张图片
 
  
 
 
  
     
   
  •  
    AbortPolicy                  超出承载就会报错
     
    •  
   
  •  
    CallerRunsPolicy         哪里来的去哪里
     
    •  
   
  •  
    DiscardPolicy               队列满了 就会丢掉 不会抛出异常
     
    •  
   
  •  
    DiscardOldestPolicy    队列满了,尝试和最早的竞争,竞争失败 也不会抛出异常
     
    •  
  
 
  
10.5 IO密集型和CPU密集型
 
  
Java中Juc并发编程基础_第10张图片
 
  
package com.bigdata.pool;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Copyright (c) 2019 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.pool
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/18 11:51
 * AbortPolicy      超出承载就会报错
 * CallerRunsPolicy 哪里来的去哪里
 * DiscardPolicy    队列满了 就会丢掉 不会抛出异常
 * DiscardOldestPolicy 队列满了,尝试和最早的竞争,竞争失败 也不会抛出异常
 */
public class Demo02 {
    public static void main(String[] args) {
        // 银行满了,还有人进来,不处理这个人的了,抛出异常
        /**
         * 最大线程到底该如何定义
         * 1. CPU 密集型 Runtime.getRuntime().availableProcessors()
         * 2. IO  密集型 判断你程序中十分耗费IO的线程 一般会设置 两倍
         *        程序  15个大型任务 IO 十分占用资源
         *        
         * 
         */
        //获取CPU 的核心数量
        int i1 = Runtime.getRuntime().availableProcessors();
        System.out.println(i1);
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2,
                Runtime.getRuntime().availableProcessors(),
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy()
        );
        try {
            // 最大承载:Deque + max
            //超出最大承载 RejectedExecutionException
            for (int i = 0; i < 9; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"ok");
                });
            }
        } finally {
            threadPool.shutdown();
        }
    }
}
 
  
11. 四大函数式接口&Stream
 
  
 
   
函数式接口 : 只有一个方法的接口
 
  
 
  
@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface Runnable is used
     * to create a thread, starting the thread causes the object's
     * run method to be called in that separately executing
     * thread.
     * 

     * The general contract of the method run is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}
// 超级多的FunctionalInterface
// 简化编程模型,在新版本的框架中大量的使用
 
  
11.1 Function 函数式接口
 
  
package func;

import java.util.function.Function;

/**
 * Copyright (c) 2019 bigdata ALL Rights Reserved
 * Project: learning
 * Package: func
 * Version: 1.0
 * Function 函数式接口
 * @author qingzhi.wu 2020/7/18 13:33
 */
public class Dmo01 {
    public static void main(String[] args) {
        //函数式接口
        Function function = (str)->{return str;};
    };
}
 
  
11.2 Predicate 消费型接口
 
  
Predicate s = (o) -> {o ==null};
Predicate s = o -> o ==null;
 
  
11.3 Consumer 消费型接口
 
  
Consumer consumer = o -> System.out.println(o);
 
  
11.4 Supplier 供给型接口
 
  
Supplier s1 = ()->"aaa";
 
  
11.4 Stream
 
  
package com.bigdata.stream;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * Copyright (c) 2019 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.stream
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/18 13:49
 */
public class Demo01 {
    public static void main(String[] args) {
        /**
         * 现在有5个用户 请进行如下筛选
         * 1. id 必须是偶数
         * 2. 年龄大于23岁
         * 3. 用户名转为大写字母
         * 4. 用户名字母倒着排序
         * 5. 只输出一个用户
         */
        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 users = Arrays.asList(u1, u2, u3, u4, u5);
        //计算交给流
        users.stream()
                .filter(u->u.getId() %2 == 0)
                .filter(u -> u.getAge()>23)
                .map(u->{
                    u.setName(u.getName().toUpperCase());
                    return u;
                })
                .sorted((uu1,uu2)->{ return uu1.getName().compareTo(uu2.getName());})

                .forEach(System.out::println);
    }
}
 
  
12.ForkJoin
 
  
Java中Juc并发编程基础_第11张图片
 
  
package com.bigdata.forkjoin;

import java.util.concurrent.RecursiveAction;
import java.util.concurrent.RecursiveTask;

/**
 * Copyright (c) 2019 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.forkjoin
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/18 15:38
 */
public class ForkJoinDemo extends RecursiveTask {
    private Long start;
    private Long end;

    private Long temp = 100000L;

    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);
            ForkJoinDemo task2 = new ForkJoinDemo(start, middle);
            task1.fork(); //拆分任务, 把任务压入线程队列
            task2.fork(); //拆分任务, 把任务压入线程队列

            return task1.join() + task2.join();
        }
    }
}
 
  
package com.bigdata.forkjoin;

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

/**
 * Copyright (c) 2019 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.forkjoin
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/18 16:01
 */
public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        test3();
    }

    // 普通
    public static void test1(){
        long start = System.currentTimeMillis();
        Long sum = 0L;
        for (long i = 1L; i < 10_0000_0000L; i++) {
            sum+=i;
        }

        long end = System.currentTimeMillis();
        System.out.println("sum=" +"时间" +(end-start)/1000.0 +"秒");
    }
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinDemo task = new ForkJoinDemo(1L,10_0000_0000L);
        ForkJoinTask submit = forkJoinPool.submit(task);
        System.out.println(submit.get());
        //Long aLong = task.get();
        long end = System.currentTimeMillis();
        System.out.println("sum=" +"时间" +(end-start));
    }
    public static void test3(){
        long start = System.currentTimeMillis();
        //Stream 并行流

        long reduce = LongStream.range(1L, 10_0000_0000L).parallel()
                .reduce(0, Long::sum);
        System.out.println(reduce);
        long end = System.currentTimeMillis();
        System.out.println("sum=" +"时间" +(end-start));
    }
}
 
  
12. 异步回调
 
  
 
   
Future 设计的初衷: 对将来某个事件进行建模
 
  
 
  
package com.bigdata.future;

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

/**
 * Copyright (c) 2019 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.future
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/18 16:18
 * 

 * 异步调用: CompletableFuture
 * 成功回调
 * 失败回调
 */
public class Demo01 {
    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");
//        });
//
//        System.out.println(11111);
//        completableFuture.get();
//      有返回值的异步回调
        CompletableFuture completableFuture = CompletableFuture.supplyAsync(() -> {
            int i = 10/0;
                    return 1024;
                }
        );

        completableFuture.whenComplete((t, u) -> {
                    System.out.println("t>" + t);
                    System.out.println("u>" + u);

                }

        ).exceptionally((e)->{
            System.out.println(e.getMessage());
            return 233;
        })
        ;
    }
}
 
  
13. JMM
 
  
 
   
请你谈谈 你对 volatile 的 理解
 
  
 
  
volatile 是Java虚拟机提供 轻量级的同步机制
 
  
     
   
  1.  
    保证可见性
     
    2.  
   
  2.  
    不保证原子性
     
    3.  
   
  3.  
    禁止指令重排
     
    4.  
  
 
  
 
   
什么是 JMM
 
  
 
  
JMM : Java内存模型,不存在的东西,概念! 约定!
 
  
关于JMM的一些同步的约定
 
  
     
   
  1.  
    线程解锁前,必须把共享变量立刻刷回主存
     
    2.  
   
  2.  
    线程加锁前,必须读取主存中的最新值到工作内存中
     
    3.  
   
  3.  
    加锁和解锁是同一把锁
     
    4.  
  
 
  
8 种操作
 
  
Java中Juc并发编程基础_第12张图片
 
  
     
   
  •  
    lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态。
     
    •  
   
  •  
    unlock（解锁）：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
     
    •  
   
  •  
    read（读取）：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的 load 动作使用
     
    •  
   
  •  
    load（载入）：作用于工作内存的变量，把 read 操作从主内存中得到的变量值放入工作内存的变量副本中。
     
    •  
   
  •  
    use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
     
    •  
   
  •  
    assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
     
    •  
   
  •  
    store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的 write 的操作。
     
    •  
   
  •  
    write（写入）：作用于主内存的变量，它把 store 操作从工作内存中一个变量的值传送到主内存的变量中。
     
    •  
  
 
  
如果要把一个变量从主内存中复制到工作内存，就需要按顺序地执行 read 和 load 操作，如果把变量从工作内存同步回主内存中，就要按顺序地执行 store 和 write 操作。Java 内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。也就是 read 和 load 之间，store 和 write 之间是可以插入其他指令的，如对主内存中的变量 a、b 进行访问时，可能的顺序是 read a，read b，load b， load a。Java 内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：
 
  
1 不允许 read 和 load、store 和write 操作之一单独出现
 
  
 
 
  
2 不允许一个线程丢弃它的最近 assign 的操作，即变量在工作内存中改变了之后必须同步到主内存中。
 
  
 
 
  
3 不允许一个线程无原因地（没有发生过任何 assign 操作）把数据从工作内存同步回主内存中。
 
  
 
 
  
4 一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load 或 assign）的变量。即对一个变量实施 use 和 store 操作之前，必须先执行过了 assign 和 load 操作。
 
  
 
 
  
5 一个变量在同一时刻只允许一条线程对其进行 lock 操作，lock 和 unlock 必须成对出现
 
  
 
 
  
6 如果对一个变量执行 lock 操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行 load 或 assign 操作初始化变量的值
 
  
 
 
  
7 如果一个变量事先没有被 lock 操作锁定，则不允许对它执行 unlock 操作；也不允许去 unlock 一个被其他线程锁定的变量
 
  
 
 
  
8 对一个变量执行 unlock 操作之前，必须先把此变量同步到主内存中（执行 store 和 write 操作）
 
  
package com.bigdata.tvolatile;

import java.util.concurrent.TimeUnit;

/**
 * Copyright (c) 2019 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.tvolatile
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/18 16:57
 */
public class JMMDemo {
    private static int num =0;
    public static void main(String[] args) {
        //main 线程
        new Thread(()->{
            while (num ==0){

            }
        }).start();
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
         
        num =1;
        System.out.println(num);

    }
}
 
  
 
 
  
 
 
  
Java中Juc并发编程基础_第13张图片
 
  
14. Volatile可见性及非原子性验证
 
  
14.1 可见性
 
  
package com.bigdata.tvolatile;

import java.util.concurrent.TimeUnit;

/**
 * Copyright (c) 2019 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.tvolatile
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/18 16:57
 */
public class JMMDemo {
    private volatile static int num =0;
    public static void main(String[] args) {
        //main 线程
        new Thread(()->{
            while (num ==0){

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

        num =1;
        System.out.println(num);

    }
}
 
  
Java中Juc并发编程基础_第14张图片
 
  
14.2 不保证原子性
 
  
原子性: 不可分割
 
  
线程A在执行任务的时候,不能被打扰的,也不能被分割,要么同时成功要么同时失败
 
  
package com.bigdata.tvolatile;

/**
 * Copyright (c) 2019 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.tvolatile
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/18 17:05
 */
public class VDemo02 {
    //volatile 不保证原子性
    private volatile static int num= 0;

    //理论上 num的结果应该为 2万
    public static void main(String[] args) {
        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);
    }

    public  static void add(){
        num++;
    }
}
 
  
 
   
如果不加lock 和 synchronized,怎么保证原子性?
 
  
 
  
Java中Juc并发编程基础_第15张图片
 
  
我们的 ++操作并不是原子性操作
 
  
 
 
  
我们可以使用原子类进行修改
 
  
    private volatile static AtomicInteger num= new AtomicInteger();

    public  static void add(){
        num.getAndIncrement(); //CAS 
    }

Unsafe类是一个很特殊的存在!
 
  
14.3 禁止指令重排
 
  
 
   
指令重排
 
  
 
  
指令重排的意思就是在我们的写完的代码之后,在编译器进行将代码编译的时候会出于一些优化,调整我们代码的执行顺序
 
  
 
   
内存屏障
 
  
 
  
     
   
  1.  
    保证特定的操作的执行顺序
     
    2.  
   
  2.  
    可以保证某些变量的内存可见性
     
    3.  
  
 
  
15.单例设计模式
 
  
package com.bigdata.singleton;

/**
 * Copyright (c) 2019 leyou ALL Rights Reserved Project: learning Package: com.bigdata.singleton
 * Version: 1.0
 *
 * @author qingzhi.wu
 * @date 2020/6/15 20:11
 */
public class LazySingleton {

  private static volatile LazySingleton instance;

  private LazySingleton() {
    synchronized (LazySingleton.class){
      if (instance != null){
        throw  new RuntimeException("不要试图使用反射破坏单例");
      }
    }

  }

  public static synchronized LazySingleton getInstance() {

    if (instance == null) {
      synchronized (LazySingleton.class) {
        if (instance == null) {
          instance = new LazySingleton();
        }
      }
    }
    return instance;
  }
}
 
  
16. CAS
 
  
16.1 什么是CAS
 
  
CAS : 比较当前工作内存中的值和主内存中的值,如果这个值是期望的,那么则执行操作,如果不是就一直循环
 
  
缺点:
 
  
     
   
  1.  
    循环会耗时
     
    2.  
   
  2.  
    一次性只能保证一个共享变量的原子性
     
    3.  
   
  3.  
    ABA问题
     
    4.  
  
 
  
16.2 ABA问题
 
  
Java中Juc并发编程基础_第16张图片
 
  
package com.bigdata.cas;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * Copyright (c) 2019 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.cas
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/18 18:09
 */
public class CASDemo {
    public static void main(String[] args) {
        //比较并交换
        //public final boolean compareAndSet(int expect, int update) {
        // 如果我期望的值达到了,那么就更新,否则就不更新 CAS 是CPU 的并发原语
        AtomicInteger atomicInteger = new AtomicInteger(2020);

        atomicInteger.compareAndSet(2020,2021);

        atomicInteger.compareAndSet(2021,2020);

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


    }
}
 
  
16.3 原子引用解决ABA问题
 
  
其实就是乐观锁的思想
 
  
package com.bigdata.cas;

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

/**
 * Copyright (c) 2019 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.cas
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/18 18:09
 */
public class CASDemo {
    static final  AtomicStampedReference atomicStampedReference = new AtomicStampedReference<>(1,1);

    public static void main(String[] args) {
        //比较并交换
        //public final boolean compareAndSet(int expect, int update) {
        // 如果我期望的值达到了,那么就更新,否则就不更新 CAS 是CPU 的并发原语
        //final AtomicInteger atomicInteger = new AtomicInteger(2020);

        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();
            System.out.println("a1=>"+atomicStampedReference.getStamp());
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(1,2,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println("a2=>"+atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(2,1,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println("a3=>"+atomicStampedReference.getStamp());

        },"A").start();

        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();
            System.out.println("b1=>"+atomicStampedReference.getStamp());
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(1,2,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println("b1=>"+atomicStampedReference.getStamp());


        },"A").start();



    }
}
 
  
17. 各种锁
 
  
17.1 公平锁,非公平锁
 
  
公平锁: 非常公平,不能插队,必须先来后到
 
  
ReentrantLock lock = new ReentrantLock(true);
 
  
非公平锁: 非常不公平,可以插队
 
  
ReentrantLock lock = new ReentrantLock();
 
  
17.2 可重入锁
 
  
可重入锁(递归锁)
 
  
Java中Juc并发编程基础_第17张图片
 
  
package com.bigdata.lock;

/**
 * Copyright (c) 2019 bigdata ALL Rights Reserved
 * Project: learning
 * Package: com.bigdata.lock
 * Version: 1.0
 *
 * @author qingzhi.wu 2020/7/18 18:44
 */
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");

    }
}
 
  
package com.bigdata.lock;

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

/**
* Copyright (c) 2019 bigdata ALL Rights Reserved
* Project: learning
* Package: com.bigdata.lock
* Version: 1.0
*
* @author qingzhi.wu 2020/7/18 18:44
*/
public class Demo02 {
   public static void main(String[] args) {
       Phone phone = new Phone();
       new Thread(()->{
           phone.sms();
      },"A").start();

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

  }

}

class Phone2 {
   Lock lock = new ReentrantLock();
   public synchronized void sms(){
       lock.lock();
       // lock 锁必须配对,不然就死锁
       try {
           System.out.println(Thread.currentThread().getName()+"sms");
           call();
      } finally {
           lock.unlock();
      }
  }
   public synchronized void call(){
       lock.lock();
       try {
           System.out.println(Thread.currentThread().getName()+"call");
      } finally {
           lock.unlock();
      }

  }
}
 
  
 
 
  
17.3 自旋锁
 
  
Java中Juc并发编程基础_第18张图片
 
  
package com.bigdata.lock;

import java.util.concurrent.atomic.AtomicReference;

/**
* Copyright (c) 2019 bigdata ALL Rights Reserved
* Project: learning
* Package: com.bigdata.lock
* Version: 1.0
*
* @author qingzhi.wu 2020/7/18 18:53
*/
public class MyLockDemo {
   static final  AtomicReference atomicReference = new AtomicReference<>();


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

      }
  }
   public void unlock(){
       Thread thread = Thread.currentThread();
       System.out.println(Thread.currentThread().getName() +"-->unlock");
       atomicReference.compareAndSet(thread,null);
  }
}
 
  
17.4 死锁
 
  
Java中Juc并发编程基础_第19张图片
 
  
package com.bigdata.demo05;

/**
* Copyright (c) 2019 bigdata ALL Rights Reserved
* Project: learning
* Package: com.bigdata.demo05
* Version: 1.0
* 死锁: 多个线程互相抱着对方需要的资源,然后形成僵持
* @author qingzhi.wu 2020/7/15 21:34
*/
public class DeadLock {
   public static void main(String[] args) {
       Mackeup g1 = new Mackeup(0,"灰姑凉");
       Mackeup g2 = new Mackeup(1,"白雪公主");
       g1.start();
       g2.start();

  }
}

//口红
class Lipstick{

}
//镜子
class Mirror{

}
class Mackeup extends Thread{
   static Lipstick lipstick = new Lipstick();
   static Mirror mirror = new Mirror();

   int choice;//选择
   String girlName;//使用化妆品的人

   public Mackeup(int choice, String girlName) {
       this.choice = choice;
       this.girlName = girlName;
  }

   @Override
   public void run() {
       //化妆
       try {
           makeup();
      } catch (InterruptedException e) {
           e.printStackTrace();
      }
  }
   private void makeup() throws InterruptedException {
       if (choice==0){
           synchronized (lipstick){//获得口红的锁
               System.out.println(this.girlName +"获得口红的锁");
               Thread.sleep(1000);
               synchronized (mirror){
                   System.out.println(this.girlName +"获得镜子的锁");

              }           }

      }else {
           synchronized (mirror){//获得口红的锁
               System.out.println(this.girlName +"获得镜子的锁");
               Thread.sleep(2000);
               synchronized (lipstick){
                   System.out.println(this.girlName +"获得口红的锁");
              }

          }

      }
  }
}
 
  
死锁的排查
 
  
     
   
  1.  
    使用jps定位进程号
     
    2.  
  
 
  
Java中Juc并发编程基础_第20张图片
 
  
     
   
  1.  
    使用jstack可以定位死锁
     
    2.  
  
 
  
Java中Juc并发编程基础_第21张图片
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Java,java,多线程,并发编程,多进程)

        

            

                
    
                    
  • java枚举实现简单的控制台计算器
                        Roc-xb
java开发语言
                        
    本文教程主要是用java枚举的方式实现一个简单的加减乘除计算器。packagecom.ruoyi;importjava.util.Scanner;publicenumCalculator{ADDITION
    
                    
    • 
                    
  • 基于 WPF 平台使用纯 C# 实现动态处理 json 字符串
                        code_shenbing
WPFwpfc#json
                        
    一、引言在当今的软件开发领域，数据的交换与存储变得愈发频繁，JSON（JavaScriptObjectNotation）作为一种轻量级的数据交换格式，以其简洁、易读、便于解析和生成的特点，被广泛应用于各种应用程序中。在WPF（WindowsPresentationFoundation）平台开发的桌面应用里，我们常常需要与各种数据源交互，动态处理JSON字符串就成为了一项必备技能。本文将深入探讨如何
    
                    
    • 
                    
  • 【Java】枚举类
                        Mr_EvanChen
JavaJavaEnum枚举类型
                        
    Java枚举知识点概念enum的全称为enumeration，是JDK1.5中引入的新特性。在Java中，被enum关键字修饰的类型就是枚举类型。形式如下：enumColor{RED,GREEN,BLUE}如果枚举不添加任何方法，枚举值默认为从0开始的有序数值。以Color枚举类型举例，它的枚举常量依次为RED：0，GREEN：1，BLUE：2。枚举的好处：可以将常量组织起来，统一进行管理。枚举的
    
                    
    • 
                    
  • Vue.js 单页应用（SPA）开发教程：从零开始构建你的第一个项目
                        Milk夜雨
vue.jsvue.js前端javascript
                        
    单页应用（SPA，SinglePageApplication）是现代前端开发的主流模式。Vue.js是一个非常适合构建SPA的框架，它通过VueRouter实现页面导航，通过组件化开发和状态管理实现复杂的交互功能。本篇教程将带你了解SPA的基本概念，并一步步创建一个Vue.js单页应用。什么是单页应用（SPA）？单页应用是一种只有一个HTML页面，通过JavaScript动态加载内容的应用。特点包
    
                    
    • 
                    
  • Node.js的解释
                        web15085415935
面试学习路线阿里巴巴node.js
                        
    1.Node.js入门教程1.1什么是Node.js？1.1.1Node.js是什么？Node.js是一个基于JavaScript的开源服务器端运行时环境，允许开发者用JavaScript编写服务器端代码。与传统的前端JavaScript主要运行在浏览器端不同，Node.js通过提供一个非阻塞的异步模型，允许开发者在服务器端创建高性能的网络应用程序。比喻：想象你把JavaScript看作是一个厨师
    
                    
    • 
                    
  • 华为OD机试详解：分苹果问题的多语言实现与算法解析
                        m0_57781768
华为od算法
                        
    华为OD机试详解：分苹果问题的多语言实现与算法解析在华为OD机试中，分苹果问题是典型的算法考题之一，考察了考生对于位运算的理解和应用。这道题的难点在于A和B两人的计算规则差异。A希望根据他的二进制加法规则来等分苹果，而B则希望在满足A的规则下，自己获得最多的苹果。本文将通过详细的解题思路及C++、Java、JavaScript、Python四种语言的实现，帮助你掌握这个问题的解决方法。题目描述A和
    
                    
    • 
                    
  • windows安装ES
                        我的棉裤丢了
elasticsearch大数据搜索引擎
                        
    1.下载ES访问ES官网下载DownloadElasticsearch|Elastic2.配置环境变量ES_JAVA_HOME:D:\jdk-17.0.9ES_HOME:D:\elasticsearch-8.17.1-windows-x86_64\elasticsearch-8.17.13.添加一些ES的配置关闭ES安全认证打开elasticsearch-8.17.1\config\elastic
    
                    
    • 
                    
  • Spring Boot 集成 Redis 全解析
                        翻晒时光
springbootspringbootredis
                        
    在当今快速发展的互联网应用开发中，性能和效率是至关重要的因素。Redis作为一款高性能的内存数据库，常被用于缓存、消息队列、分布式锁等场景，能够显著提升应用程序的响应速度和吞吐量。SpringBoot以其强大的自动配置和快速开发特性，成为众多Java开发者的首选框架。将SpringBoot与Redis集成，可以充分发挥两者的优势，构建出高效、稳定的应用系统。本文将详细介绍SpringBoot集成R
    
                    
    • 
                    
  • 深入Java编程：经典课程设计案例剖析
                        脑叔

                        
    本文还有配套的精品资源，点击获取简介：Java课程设计是提高编程技能的重要途径，包含了Java基础语法、面向对象编程、异常处理、集合框架、IO流、多线程、网络编程、数据库连接、GUI编程、设计模式以及单元测试等多个方面。本集合详细介绍了这些关键知识点，并通过经典案例教学，帮助学生和开发者巩固理论知识，提升解决实际问题的能力，为未来的软件开发工作奠定坚实基础。1.Java基础语法精讲1.1Java程
    
                    
    • 
                    
  • Java中如何导包
                        道长爱睡懒觉
后端（Java）从入门到开发java开发语言
                        
    目录导包导包方法Scanner包导入Scanner包创建Scanner类对象键盘录入对象调用方法总结导包其实Java的包和C/C++的库，python的Model是一样的，是可以使用的现成功能，我们可以称他们为基本库，一个语言的特性，成熟程度，与这个语言的基本库有很大关系，Java从产生至今，他的库一直在不断的修改和扩充，Java的功能也随之变得更加的成熟和强大。在Java代码中导入包，与其说为了
    
                    
    • 
                    
  • [2951]基于JAVA的贫困生资助智慧管理系统的设计与实现
                        阿鑫学长【毕设工场】
java人工智能开发语言课程设计毕业设计
                        
    毕业设计（论文）开题报告表姓名学院专业班级题目基于JAVA的贫困生资助智慧管理系统的设计与实现指导老师（一）选题的背景和意义一、选题背景随着信息技术的快速发展，信息化管理已经深入到社会各个领域。在教育行业中，学生资助工作是学校管理的重要组成部分，涉及到学生的切身利益和学校的公正公平。然而，在传统的管理模式下，贫困生资助工作往往存在信息不透明、流程繁琐、效率低下等问题。Java作为一种面向对象的编程
    
                    
    • 
                    
  • Java 23新特性：Class-File API
                        leonidZhao
java开发语言
                        
    JEP466:Class-FileAPI(SecondPreview)JEP466:Class-FileAPI，该特性为第二次预览，在Java22中首次预览，并将在Java24中成为正式特性。目前已经存在一些工具可以处理类文件，例如ASM，BCEL，Javassist。该特性不是为了解决效率或代码分析问题，也不是CoreReflectionAPI的扩展。该特性的出现只是为了提供一个标准的类文件处理
    
                    
    • 
                    
  • 基于springbootBBS论坛系统的设计与实现
                        四金学长
计算机毕业设计参考案例springbootmavenjavaBBS论坛系统
                        
    1.引言在当今的软件开发领域，企业级应用的开发和部署速度直接影响着业务的竞争力。SpringBoot以其轻量级、快速启动和强大的集成能力，成为构建现代企业级应用的首选框架。本文将带您深入了解SpringBoot框架的核心特性，并展示如何利用它构建一个高效、可扩展的系统。2.开发环境开发语言：Java框架：springbootJD版本：JDK1.8服务器：tomcat7数据库：mysql5.7（一定
    
                    
    • 
                    
  • SpringBoot为什么要禁止循环依赖?
                        java1234_小锋
javajava开发语言
                        
    大家好，我是锋哥。今天分享关于【SpringBoot为什么要禁止循环依赖?】面试题。希望对大家有帮助；SpringBoot为什么要禁止循环依赖?1000道互联网大厂Java工程师精选面试题-Java资源分享网SpringBoot禁止循环依赖的原因与Spring框架本身的设计和依赖注入机制密切相关。以下是详细解释：1.依赖注入的基本原理在Spring框架中，依赖注入（DependencyInject
    
                    
    • 
                    
  • 【JAVA】我和我的第一个“对象”相遇
                        2401_89791130
java开发语言
                        
    表达式1必须是一个布尔表达式如果表达式1为真，那么执行表达式2，否则执行表达式3自我检验根据以下代码思考打印的结果是什么？publicclassTestDemo2{publicstaticvoidmain(String[]args){booleanflg=true==true?true:true==false?false:false;System.out.println(flg);booleanf
    
                    
    • 
                    
  • 基于数据可视化SpringBoot+Vue+Uniapp的学生活动管理系统设计与实现（毕业设计实战项目+源码+部署）
                        Java开源领先者
#Java网站项目#微信小程序毕设#Java精品毕设信息可视化springbootvue.js毕业设计javauni-app学生活动管理
                        
    博主介绍CSDN毕设辅导第一人、靠谱第一人、全网粉丝50W+,csdn特邀作者、博客专家、腾讯云社区合作讲师、CSDN新星计划导师、Java领域优质创作者,博客之星、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和学生毕业项目实战,高校老师/讲师/同行前辈交流✌技术范围：SpringBoot、Vue、SSM、HLMT、Jsp、PHP、Nodejs、Python、爬虫、数据可
    
                    
    • 
                    
  • 【Java 学习】Java抽象类详解：从理论到实践，带你迈向面向对象的深度思考！
                        Code哈哈笑
Java拾光之旅java学习开发语言
                        
    欢迎讨论：如对文章内容有疑问或见解，欢迎在评论区留言，我需要您的帮助！点赞、收藏与分享：如果这篇文章对您有所帮助，请不吝点赞、收藏或分享，谢谢您的支持！传播技术之美：期待您将这篇文章推荐给更多对需要学习Java语言、低代码开发感兴趣的朋友，让我们共同学习、成长！1.什么是抽象类？举一个Animal类、Cat类和Dog类的例子：classAnimal{publicvoideat(){System.o
    
                    
    • 
                    
  • 打造高效React应用：CSS方案深度解析
                        

                        
    大家好，我是长林啊！一个爱好JavaScript、Go、Rust的全栈开发者；致力于终生学习和技术分享。在React以其声明式编程范式和组件化架构，成为了构建用户界面的首选技术之一。然而，随着项目规模的扩大和设计需求的多样化，如何高效地管理CSS样式成为了每个React开发者都需要面对的挑战。本文将从一下三个方面进行介绍，探讨如何在React中应用和管理样式，包括内联样式、CSS类、CSSModu
    
                    
    • 
                    
  • 【JAVA 基础 第（20）课】JDBC JAVA 连接 MySql 数据库
                        黑口罩
【JAVA】系列java
                        
    pom.xml导入MySqljar包mysqlmysql-connector-java5.1.30数据库驱动、连接封装成一个工具类DBUtil类importjava.sql.Connection;importjava.sql.DriverManager;importjava.sql.ResultSet;importjava.sql.SQLException;importjava.sql.State
    
                    
    • 
                    
  • 使用基于 WebRTC 的 JavaScript API 在浏览器环境里调用本机摄像头
                        

                        
    Python中的class体内定义方法时，如果没有显式地包含self参数，有时候依然可以被调用。这是一个非常有趣的话题，因为它涉及到对Python中类与对象之间关系的更深理解。要理解为什么这种情况下方法依然能够被调用，我们需要逐步拆解Python类的构造方式以及方法绑定的原理。
    
                    
    • 
                    
  • 分布式微服务搭建
                        Xi-Tong
微服务架构云原生linuxcentosbashjdk
                        
    分布式微服务架构搭建（举出一个项目搭建的例子，其他项目可参考本文档）基于Nginx作为web服务器、JDK作为Java运行环境、MySQL作为关系型数据库、Nacos作为服务发现和配置中心、Maven作为项目管理工具、Redis作为缓存和消息中间件（视具体需求而定）、Node.js与npm作为某些微服务（如前端服务或特定业务逻辑服务）的开发和依赖管理工具，可以搭建一个完整的分布式微服务架构项目。以
    
                    
    • 
                    
  • SkyWalking
                        小馋喵知识杂货铺
性能skywalking
                        
    SkyWalking是一款开源的APM（ApplicationPerformanceManagement）工具，主要用于监控、追踪和诊断微服务架构中的应用性能。它支持多种语言，包括Java、Go、Node.js、Python等，能够提供强大的分布式追踪、日志分析、性能监控等功能，是微服务和云原生架构中重要的性能管理工具之一。SkyWalking最初由ApacheSoftwareFoundation
    
                    
    • 
                    
  • java 解析PDF文件里面的表格并转换成EXCEL，不是表格的不会解析
                        妳、终究不属于涐
javapdfexcel
                        
    importcom.collection.integration.constant.ReminderConstant;importcom.spire.pdf.PdfDocument;importcom.spire.pdf.utilities.PdfTable;importcom.spire.pdf.utilities.PdfTableExtractor;importcom.spire.xls.Ex
    
                    
    • 
                    
  • Android为什么要从Java改用Kotlin
                        彬sir哥
Androidkotlin入门到进阶系列讲解androidandroidstudiojavakotlin
                        
    <<返回总目录文章目录一、Kotlin1、Kotlin是来自哪个公司2、为什么要学习Kotlin二、Android的Kotlin优先方法1、为什么要优先使用Kotlin进行Android开发？2、Kotlin优先意味着什么？一、Kotlin1、Kotlin是来自哪个公司kotlin是来自JetBrains公司2、为什么要学习Kotlin市场上大部分代码都是kotlin了，没办法有些项目组件不切an
    
                    
    • 
                    
  • docker实践与应用举例
                        周盛欢
docker
                        
    第一步：搞清楚Docker是啥玩意儿Docker是个啥？简单来说，它就像是一个“打包神器”。你可以把你的程序、代码、运行环境（比如Python、Java、数据库之类的）全部打包成一个“盒子”，然后这个“盒子”可以放到任何地方运行，不用担心环境问题。这就像是你把一个玩具打包好，不管带到哪里，都能拿出来玩，而且不会坏。为啥要用Docker呢？因为它能解决“在我电脑上能运行，但到你电脑上就报错”的问题。
    
                    
    • 
                    
  • React 前端框架简介与应用
                        仰望丨苍穹
前端：技巧与实践前端框架react.js前端
                        
    React是一个用于构建用户界面的JavaScript库，在前端开发中被广泛应用。1：主要特点1.1：组件化开发React提倡以组件的方式构建用户界面。每个组件都具有独立的功能和逻辑，可以重复使用和组合，提高了开发效率和代码的可维护性。例如，一个网页中的导航栏、侧边栏、内容区域等都可以分别构建为不同的组件。1.2：虚拟DOMReact引入了虚拟DOM（VirtualDOM）的概念。当数据发生变化时
    
                    
    • 
                    
  • React 前端框架：简介与核心概念
                        一ge科研小菜鸡
工具前端框架
                        
    React是由Facebook开发和维护的一个用于构建用户界面的JavaScript库。它专注于通过组件化的方式构建单页应用（SPA），允许开发者高效地创建复杂、交互性强的界面。React的核心特点是其虚拟DOM、组件化开发和声明式编程，使其成为目前最流行的前端开发框架之一。1.React的优势1.1组件化开发React的核心是组件（Component），它允许开发者将界面划分为多个独立的、可重用
    
                    
    • 
                    
  • 如何通过减少HTTP请求来提升页面加载速度？
                        破碎的天堂鸟
学习教程http网络协议网络
                        
    通过减少HTTP请求可以显著提升网页加载速度，这是因为HTTP请求的次数直接影响了页面加载时间。以下是一些具体的方法和策略：1.合并文件将多个CSS文件合并为一个CSS文件，将多个JavaScript文件合并为一个JavaScript文件。这可以减少浏览器发起的HTTP请求次数，从而加快页面加载速度。示例：将所有样式表和脚本文件打包成一个文件，以减少请求数量。2.使用CSSSprites（雪碧图）
    
                    
    • 
                    
  • 贪心算法之区间选点问题
                        阿贾克斯的黎明
java贪心算法算法
                        
    目录贪心算法之区间选点问题1.区间选点问题概述2.基本区间选点问题的贪心策略（1）策略思路（2）具体示例3.区间选点问题变体及处理（1）变体描述（2）贪心策略调整（3）示例演示4.Java实现代码及解释（1）定义区间类（2）贪心算法实现（3）代码解释5.性能优化（1）当前实现的性能问题（2）树状数组优化思路（3）示例代码片段（树状数组相关操作）（4）优化后的性能分析6.总结与展望（1）区间选点问题
    
                    
    • 
                    
  • 【前端开发】前端开发深度解析：HTML、CSS、JavaScript与Vue.js
                        RS迷途小书童
前端开发探索之旅javascripthtmlcss前端vue.js
                        
    一、HTML：构建网页的基石1.1简介HTML（HyperTextMarkupLanguage，超文本标记语言）是一种用于创建网页的标准标记语言。它使用各种标签（tags）来描述网页上的内容，包括文本、图像、链接、视频、音频等。HTML是网页开发的基础，与CSS（层叠样式表）和JavaScript等技术一起，共同构建出丰富多彩的网页世界。HTML文档由一系列的元素构成，每个元素都由开始标签、内容和
    
                    
    • 
                                
  • Java开发中，spring mvc 的线程怎么调用？
                                    小麦麦子
springmvc
                                    
    今天逛知乎，看到最近很多人都在问spring mvc 的线程http://www.maiziedu.com/course/java/ 的启动问题，觉得挺有意思的，那哥们儿问的也听仔细，下面的回答也很详尽，分享出来，希望遇对遇到类似问题的Java开发程序猿有所帮助。 
 
问题： 
    在用spring mvc架构的网站上，设一线程在虚拟机启动时运行，线程里有一全局
    
                                
    • 
                                
  • maven依赖范围
                                    bitcarter
maven
                                    
    1.test 测试的时候才会依赖，编译和打包不依赖，如junit不被打包 
 
2.compile 只有编译和打包时才会依赖 
 
3.provided 编译和测试的时候依赖，打包不依赖，如：tomcat的一些公用jar包 
 
4.runtime 运行时依赖，编译不依赖 
 
5.默认compile 
 
依赖范围compile是支持传递的，test不支持传递 
 
1.传递的意思是项目A，引用
    
                                
    • 
                                
  • Jaxb org.xml.sax.saxparseexception : premature end of file
                                    darrenzhu
xmlprematureJAXB
                                    
    如果在使用JAXB把xml文件unmarshal成vo(XSD自动生成的vo)时碰到如下错误： 
org.xml.sax.saxparseexception : premature end of file 
很有可能时你直接读取文件为inputstream，然后将inputstream作为构建unmarshal需要的source参数。InputSource inputSource = new In
    
                                
    • 
                                
  • CSS Specificity
                                    周凡杨
html权重Specificitycss
                                    
      
有时候对于页面元素设置了样式，可为什么页面的显示没有匹配上呢？ because specificity   
CSS 的选择符是有权重的，当不同的选择符的样式设置有冲突时，浏览器会采用权重高的选择符设置的样式。   
    规则： 
  
  HTML标签的权重是1

  Class 的权重是10

  Id 的权重是100


    
                                
    • 
                                
  • java与servlet
                                    g21121
servlet
                                    
    servlet 搞java web开发的人一定不会陌生，而且大家还会时常用到它。 
下面是java官方网站上对servlet的介绍：  java官网对于servlet的解释 写道   
Java Servlet Technology Overview Servlets are the Java platform technology of choice for extending and enha
    
                                
    • 
                                
  • eclipse中安装maven插件
                                    510888780
eclipsemaven
                                    
    1.首先去官网下载 Maven： 
http://www.apache.org/dyn/closer.cgi/maven/binaries/apache-maven-3.2.3-bin.tar.gz 
下载完成之后将其解压， 
我将解压后的文件夹：apache-maven-3.2.3， 
并将它放在 D:\tools目录下， 
即 maven 最终的路径是：D:\tools\apache-mave
    
                                
    • 
                                
  • jpa@OneToOne关联关系
                                    布衣凌宇
jpa
                                    
    Nruser里的pruserid关联到Pruser的主键id，实现对一个表的增删改，另一个表的数据随之增删改。 
Nruser实体类 
//***************************************************************** 
@Entity 
@Table(name="nruser") 
@DynamicInsert @Dynam
    
                                
    • 
                                
  • 我的spring学习笔记11-Spring中关于声明式事务的配置
                                    aijuans
spring事务配置
                                    
    这两天学到事务管理这一块，结合到之前的terasoluna框架，觉得书本上讲的还是简单阿。我就把我从书本上学到的再结合实际的项目以及网上看到的一些内容，对声明式事务管理做个整理吧。我看得Spring in Action第二版中只提到了用TransactionProxyFactoryBean和<tx:advice/>,定义注释驱动这三种，我承认后两种的内容很好，很强大。但是实际的项目当中
    
                                
    • 
                                
  • java 动态代理简单实现
                                    antlove
javahandlerproxydynamicservice
                                    
    dynamicproxy.service.HelloService 
package dynamicproxy.service;

public interface HelloService {
	public void sayHello();
}
 
  
dynamicproxy.service.impl.HelloServiceImpl 
package dynamicp
    
                                
    • 
                                
  • JDBC连接数据库
                                    百合不是茶
JDBC编程JAVA操作oracle数据库
                                    
          
    如果我们要想连接oracle公司的数据库，就要首先下载oralce公司的驱动程序，将这个驱动程序的jar包导入到我们工程中; 
  
JDBC链接数据库的代码和固定写法; 
  
  
1,加载oracle数据库的驱动; 
    &nb
    
                                
    • 
                                
  • 单例模式中的多线程分析
                                    bijian1013
javathread多线程java多线程
                                    
    谈到单例模式，我们立马会想到饿汉式和懒汉式加载，所谓饿汉式就是在创建类时就创建好了实例，懒汉式在获取实例时才去创建实例，即延迟加载。 
饿汉式： 
package com.bijian.study;

public class Singleton {

	private Singleton() {
	}

	// 注意这是private 只供内部调用
	private static
    
                                
    • 
                                
  • javascript读取和修改原型特别需要注意原型的读写不具有对等性
                                    bijian1013
JavaScriptprototype
                                    
            对于从原型对象继承而来的成员，其读和写具有内在的不对等性。比如有一个对象A，假设它的原型对象是B，B的原型对象是null。如果我们需要读取A对象的name属性值，那么JS会优先在A中查找，如果找到了name属性那么就返回；如果A中没有name属性，那么就到原型B中查找name，如果找到了就返回；如果原型B中也没有
    
                                
    • 
                                
  • 【持久化框架MyBatis3六】MyBatis3集成第三方DataSource
                                    bit1129
dataSource
                                    
    MyBatis内置了数据源的支持，如： 
  
	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC" />
			<data
    
                                
    • 
                                
  • 我程序中用到的urldecode和base64decode,MD5
                                    bitcarter
cMD5base64decodeurldecode
                                    
    这里是base64decode和urldecode，Md5在附件中。因为我是在后台所以需要解码： 
 

string Base64Decode(const char* Data,int DataByte,int& OutByte)
{
    //解码表
    const char DecodeTable[] =
    {
        0, 0, 0, 0, 0, 0
    
                                
    • 
                                
  • 腾讯资深运维专家周小军：QQ与微信架构的惊天秘密
                                    ronin47

                                    
    社交领域一直是互联网创业的大热门，从PC到移动端，从OICQ、MSN到QQ。到了移动互联网时代，社交领域应用开始彻底爆发，直奔黄金期。腾讯在过去几年里，社交平台更是火到爆，QQ和微信坐拥几亿的粉丝，QQ空间和朋友圈各种刷屏，写心得，晒照片，秀视频，那么谁来为企鹅保驾护航呢？支撑QQ和微信海量数据背后的架构又有哪些惊天内幕呢？本期大讲堂的内容来自今年2月份ChinaUnix对腾讯社交网络运营服务中心
    
                                
    • 
                                
  • java-69-旋转数组的最小元素。把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素
                                    bylijinnan
java
                                    
    

public class MinOfShiftedArray {

	/**
	 * Q69 旋转数组的最小元素
	 * 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素。
	 * 例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。
	 */
	publ
    
                                
    • 
                                
  • 看博客，应该是有方向的
                                    Cb123456
反省看博客
                                    
    看博客，应该是有方向的: 
 我现在就复习以前的，在补补以前不会的，现在还不会的，同时完善完善项目，也看看别人的博客. 
 我刚突然想到的: 
 1.应该看计算机组成原理，数据结构，一些算法，还有关于android,java的。 
 2.对于我，也快大四了，看一些职业规划的，以及一些学习的经验，看看别人的工作总结的. 
  
 为什么要写
    
                                
    • 
                                
  • [开源与商业]做开源项目的人生活上一定要朴素,尽量减少对官方和商业体系的依赖
                                    comsci
开源项目
                                    
     
 
     为什么这样说呢？  因为科学和技术的发展有时候需要一个平缓和长期的积累过程，但是行政和商业体系本身充满各种不稳定性和不确定性，如果你希望长期从事某个科研项目，但是却又必须依赖于某种行政和商业体系，那其中的过程必定充满各种风险。。。 
 
      所以，为避免这种不确定性风险，我
    
                                
    • 
                                
  • 一个 sql优化 （[精华] 一个查询优化的分析调整全过程！很值得一看 ）
                                    cwqcwqmax9
sql
                                    
    见   http://www.itpub.net/forum.php?mod=viewthread&tid=239011 
 
 
 
 
Web翻页优化实例 
 提交时间: 2004-6-18 15:37:49      回复    发消息  
 
 
环境： 
Linux ve
    
                                
    • 
                                
  • Hibernat and Ibatis
                                    dashuaifu
Hibernateibatis
                                    
    Hibernate  VS  iBATIS 简介 Hibernate 是当前最流行的O/R mapping框架，当前版本是3.05。它出身于sf.net，现在已经成为Jboss的一部分了 iBATIS 是另外一种优秀的O/R mapping框架，当前版本是2.0。目前属于apache的一个子项目了。 相对Hibernate“O/R”而言，iBATIS 是一种“Sql Mappi
    
                                
    • 
                                
  • 备份MYSQL脚本
                                    dcj3sjt126com
mysql
                                    
    #!/bin/sh
# this shell to backup mysql
#[email protected] (QQ:1413161683 DuChengJiu)

_dbDir=/var/lib/mysql/
_today=`date +%w`
_bakDir=/usr/backup/$_today
[ ! -d $_bakDir ] && mkdir -p 
    
                                
    • 
                                
  • iOS第三方开源库的吐槽和备忘
                                    dcj3sjt126com
ios
                                    
    转自 
ibireme的博客       做iOS开发总会接触到一些第三方库，这里整理一下，做一些吐槽。       目前比较活跃的社区仍旧是Github，除此以外也有一些不错的库散落在Google Code、SourceForge等地方。由于Github社区太过主流，这里主要介绍一下Github里面流行的iOS库。       首先整理了一份 
Github上排名靠
    
                                
    • 
                                
  • html wlwmanifest.xml
                                    eoems
htmlxml
                                    
    所谓优化wp_head()就是把从wp_head中移除不需要元素，同时也可以加快速度。 
 
步骤： 
 
加入到function.php 
 
remove_action('wp_head', 'wp_generator'); 
//wp-generator移除wordpress的版本号，本身blog的版本号没什么意义，但是如果让恶意玩家看到，可能会用官网公布的漏洞攻击blog 
 
remov
    
                                
    • 
                                
  • 浅谈Java定时器发展
                                    hacksin
java并发timer定时器
                                    
    java在jdk1.3中推出了定时器类Timer,而后在jdk1.5后由Dou Lea从新开发出了支持多线程的ScheduleThreadPoolExecutor，从后者的表现来看，可以考虑完全替代Timer了。 
Timer与ScheduleThreadPoolExecutor对比： 
1. 
  
 Timer始于jdk1.3,其原理是利用一个TimerTask数组当作队列
    
                                
    • 
                                
  • 移动端页面侧边导航滑入效果
                                    ini
jqueryWebhtml5cssjavascirpt
                                    
    效果体验：http://hovertree.com/texiao/mobile/2.htm可以使用移动设备浏览器查看效果。效果使用到jquery-2.1.4.min.js，该版本的jQuery库是用于支持HTML5的浏览器上，不再兼容IE8以前的浏览器，现在移动端浏览器一般都支持HTML5，所以使用该jQuery没问题。HTML文件代码： 
<!DOCTYPE html>
<h
    
                                
    • 
                                
  • AspectJ+Javasist记录日志
                                    kane_xie
aspectjjavasist
                                    
    在项目中碰到这样一个需求，对一个服务类的每一个方法，在方法开始和结束的时候分别记录一条日志，内容包括方法名，参数名+参数值以及方法执行的时间。 
  
@Override
public String get(String key) {
//	long start = System.currentTimeMillis();
//	System.out.println("Be
    
                                
    • 
                                
  • redis学习笔记
                                    MJC410621
redisNoSQL
                                    
    1)nosql数据库主要由以下特点：非关系型的、分布式的、开源的、水平可扩展的。 
1，处理超大量的数据 
2，运行在便宜的PC服务器集群上， 
3，击碎了性能瓶颈。 
1)对数据高并发读写。 
2)对海量数据的高效率存储和访问。 
3)对数据的高扩展性和高可用性。 
 
redis支持的类型： 
 
Sring 类型 
set name lijie 
get name lijie 
set na
    
                                
    • 
                                
  • 使用redis实现分布式锁
                                    qifeifei

                                    
    在多节点的系统中，如何实现分布式锁机制，其中用redis来实现是很好的方法之一，我们先来看一下jedis包中，有个类名BinaryJedis,它有个方法如下： 
  
public Long setnx(final byte[] key, final byte[] value) {
	checkIsInMulti();
	client.setnx(key, value);
	ret
    
                                
    • 
                                
  • BI并非万能，中层业务管理报表要另辟蹊径
                                    张老师的菜
大数据BI商业智能信息化
                                    
           BI是商业智能的缩写，是可以帮助企业做出明智的业务经营决策的工具，其数据来源于各个业务系统，如ERP、CRM、SCM、进销存、HER、OA等。 
       BI系统不同于传统的管理信息系统，他号称是一个整体应用的解决方案，是融入管理思想的强大系统：有着系统整体的设计思想，支持对所有
    
                                
    • 
                                
  • 安装rvm后出现rvm not a function 或者ruby -v后提示没安装ruby的问题
                                    wudixiaotie
function
                                    
    1.在~/.bashrc最后加入 
[[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm" 
 2.重新启动terminal输入： 
  
rvm use ruby-2.2.1 --default 
 把当前安装的ruby版本设为默
    
                                
    •