java复制代码/**
 * 小和问题：在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。要求时间复杂度O(N*logN) 
 *
 * @author Java和算法学习：周一
 */
public class SmallSum {

    public static int smallSum(int[] arr) {
        if (arr == null || arr.length < 2) {
            return 0;
        }
        return process(arr, 0, arr.length - 1);
    }

    private static int process(int[] arr, int l, int r) {
        if (l == r) {
            return 0;
        }
        int mid = l + ((r - l) >> 1);
        return process(arr, l, mid) + process(arr, mid + 1, r) + merge(arr, l, mid, r);
    }

    private static int merge(int[] arr, int l, int mid, int r) {
        int[] help = new int[r - l + 1];
        int i = 0;

        int pL = l;
        int pR = mid + 1;
        int res = 0;
        while (pL <= mid && pR <= r) {
            // 当左组的数小于右组的数时， 当前右组的个数*当前数 的累加和 即是小和的结果
            // 仔细和归并排序比较，发现就多了此处的代码。唯一的区别是，
            // 等于的时候拷贝右组的，因为要在右组中找出比左组大的个数，肯定不能先拷贝左组的，不然咋找出个数
            res += arr[pL] < arr[pR] ? (r - pR + 1) * arr[pL] : 0;
            help[i++] = arr[pL] < arr[pR] ? arr[pL++] : arr[pR++];
        }
        while (pL <= mid) {
            help[i++] = arr[pL++];
        }
        while (pR <= r) {
            help[i++] = arr[pR++];
        }

        for (int j = 0; j < help.length; j++) {
            arr[l + j] = help[j];
        }
        return res;
    }

    /**
     * 对数器方法
     */
    public static int comparator(int[] arr) {
        int res = 0;
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < i; j++) {
                res += arr[j] < arr[i] ? arr[j] : 0;
            }
        }
        return res;
    }

    public static void main(String[] args) {
        int maxSize = 100;
        int maxValue = 100;
        int testTimes = 100000;

        boolean isSuccess = true;
        for (int i = 0; i < testTimes; i++) {
            int[] arr1 = generateArray(maxSize, maxValue);
            int[] arr2 = copyArray(arr1);
            if (smallSum(arr1) != comparator(arr2)) {
                printArray(arr1);
                printArray(arr2);
                isSuccess = false;
                break;
            }
        }
        System.out.println(isSuccess ? "Nice" : "Error");
    }

    //------------------------------------------ TEST METHODS ----------------------------------------------

    public static int[] generateArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) ((maxValue + 1) * Math.random());
        }
        return arr;
    }

    public static int[] copyArray(int[] arr) {
        if (arr == null) {
            return null;
        }
        int[] res = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            res[i] = arr[i];
        }
        return res;
    }

    public static void printArray(int[] arr) {
        if (arr == null) {
            return;
        }
        for (int value : arr) {
            System.out.print(value + " ");
        }
        System.out.println();
    }

}

java复制代码/**
 * 逆序对问题：设有一个数组 [a1, a2, a3,... an]，对于数组中任意两个元素ai，aj，若i<j 且 ai>aj，则说明ai和aj是一对逆序对。
 * 求一个给定数组的逆序对个数。
 *
 * @author Java和算法学习：周一
 */
public class ReversePair {

    public static int reversePairNum(int[] arr) {
        if (arr == null || arr.length < 2) {
            return 0;
        }
        return process(arr, 0, arr.length - 1);
    }

    private static int process(int[] arr, int l, int r) {
        if (l == r) {
            return 0;
        }
        int mid = l + ((r - l) >> 1);
        return process(arr, l, mid) + process(arr, mid + 1, r) + merge(arr, l, mid, r);
    }

    private static int merge(int[] arr, int l, int mid, int r) {
        // 辅助数组
        int[] help = new int[r - l + 1];
        // 辅助下标，由于从右往左合并，所以下标为数组最大值
        int i = help.length - 1;

        // 同理，左组第一个数位置为mid
        int pL = mid;
        // 右组第一个数为最后一个
        int pR = r;
        // 逆序对个数
        int num = 0;
        while (pL >= l && pR >= (mid + 1)) {
            // 找到右组第一个比左组小的数，则当前满足要求的逆序对个数为 (pR - (mid + 1) + 1) 即是 (pR - mid)
            num += arr[pL] > arr[pR] ? (pR - mid) : 0;
            // 从右往左拷贝，相等的拷贝右组的
            help[i--] = arr[pL] > arr[pR] ? arr[pL--] : arr[pR--];
        }
        // 左组和右组有且仅有一个未拷贝完，所以以下两个循环只会执行其中一个
        while (pL >= l) {
            help[i--] = arr[pL--];
        }
        while (pR > mid) {
            help[i--] = arr[pR--];
        }

        // 拷贝回原数组
        for (int j = 0; j < help.length; j++) {
            arr[l + j] = help[j];
        }
        return num;
    }

    /**
     * 对数器用于测试
     */
    public static int comparator(int[] arr) {
        int num = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[i]) {
                    num++;
                }
            }
        }
        return num;
    }

    public static void main(String[] args) {
        int testTime = 1000000;
        int maxSize = 100;
        int maxValue = 100;

        boolean isSuccess = true;
        for (int i = 0; i < testTime; i++) {
            int[] arr1 = generateRandomArray(maxSize, maxValue);
            int[] arr2 = copyArray(arr1);
            if (reversePairNum(arr1) != comparator(arr2)) {
                printArray(arr1);
                printArray(arr2);
                isSuccess = false;
                break;
            }
        }
        System.out.println(isSuccess ? "Nice" : "Error");
    }

    //--------------------------------------- 辅助测试的方法 ---------------------------------------------

    public static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) ((maxValue + 1) * Math.random());
        }
        return arr;
    }

    public static int[] copyArray(int[] arr) {
        if (arr == null) {
            return null;
        }

        int[] res = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            res[i] = arr[i];
        }
        return res;
    }

    public static void printArray(int[] arr) {
        if (arr == null) {
            return;
        }

        for (int value : arr) {
            System.out.print(value + " ");
        }
        System.out.println();
    }

}

java复制代码source1.join(source2)
  .where(Keyselector)
  .equalTo(keySelector)
  .window()
  .process()
  .addsink();

arduino复制代码stream.join(stream2)
                .where(tuple -> tuple.f0)
                .equalTo(tuple -> tuple.f0)
                .window(TumblingEventTimeWindows.of(Time.milliseconds(10)))
                .allowedLateness(Time.milliseconds(30))
                .apply(new JoinWindowResult())
                .addSink(new CommonPrintSink<>("流join"));

java复制代码public <T> DataStream<T> apply(
                JoinFunction<T1, T2, T> function, TypeInformation<T> resultType) {
  // clean the closure
  function = input1.getExecutionEnvironment().clean(function);

  // 将join操作转化为coGroup操作
  coGroupedWindowedStream =
    input1.coGroup(input2)
    .where(keySelector1)
    .equalTo(keySelector2)
    .window(windowAssigner)
    .trigger(trigger)
    .evictor(evictor)
    .allowedLateness(allowedLateness);

  return coGroupedWindowedStream.apply(new JoinCoGroupFunction<>(function), resultType);
}
  
  
  @Override
  public void coGroup(Iterable<T1> first, Iterable<T2> second, Collector<T> out)
    throws Exception {
    for (T1 val1 : first) {
      for (T2 val2 : second) {
      // 调用实现的join方法
        out.collect(wrappedFunction.join(val1, val2));
      }
    }
  }

java复制代码DataStream<TaggedUnion<T1, T2>> unionStream = taggedInput1.union(taggedInput2);

            // we explicitly create the keyed stream to manually pass the key type information in
            windowedStream =
                    new KeyedStream<TaggedUnion<T1, T2>, KEY>(
                                    unionStream, unionKeySelector, keyType)
                            .window(windowAssigner);

            if (trigger != null) {
                windowedStream.trigger(trigger);
            }
            if (evictor != null) {
                windowedStream.evictor(evictor);
            }
            if (allowedLateness != null) {
                windowedStream.allowedLateness(allowedLateness);
            }

            return windowedStream.apply(
                    new CoGroupWindowFunction<T1, T2, T, KEY, W>(function), resultType);


==================================================================
  public static class TaggedUnion<T1, T2> {
        private final T1 one;
        private final T2 two;
    
    
 ===============================================================
    
 private static class CoGroupWindowFunction<T1, T2, T, KEY, W extends Window>
            extends WrappingFunction<CoGroupFunction<T1, T2, T>>
            implements WindowFunction<TaggedUnion<T1, T2>, T, KEY, W> {

        private static final long serialVersionUID = 1L;

        public CoGroupWindowFunction(CoGroupFunction<T1, T2, T> userFunction) {
            super(userFunction);
        }

        @Override
        public void apply(KEY key, W window, Iterable<TaggedUnion<T1, T2>> values, Collector<T> out)
                throws Exception {

            List<T1> oneValues = new ArrayList<>();
            List<T2> twoValues = new ArrayList<>();

            for (TaggedUnion<T1, T2> val : values) {
                if (val.isOne()) {
                    oneValues.add(val.getOne());
                } else {
                    twoValues.add(val.getTwo());
                }
            }
            wrappedFunction.coGroup(oneValues, twoValues, out);
        }
    }

java复制代码coGroupedWindowedStream =
                    input1.coGroup(input2)
                            .where(keySelector1)
                            .equalTo(keySelector2)
                            .window(windowAssigner)
                            .trigger(trigger)
                            .evictor(evictor)
                            .allowedLateness(allowedLateness);

            return coGroupedWindowedStream.apply(new JoinCoGroupFunction<>(function), resultType);
            
            
void coGroup(Iterable<IN1> first, Iterable<IN2> second, Collector<O> out) throws Exception;

java复制代码stream.join(stream2)
                .where(tuple -> tuple.f0)
                .equalTo(tuple -> tuple.f0)
                .window(TumblingEventTimeWindows.of(Time.milliseconds(10)))
                .allowedLateness(Time.milliseconds(30))
                .apply(new JoinWindowResult())
                .addSink(new CommonPrintSink<>("流join"));

ini复制代码syntax = "proto3";

package helloworld;

option go_package = "./;helloworld";

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}

cpp复制代码[wbyq@wbyq linux_c]$ kill -l
 1) SIGHUP	 2) SIGINT	 3) SIGQUIT	 4) SIGILL	 5) SIGTRAP
 6) SIGABRT	 7) SIGBUS	 8) SIGFPE	 9) SIGKILL	10) SIGUSR1
11) SIGSEGV	12) SIGUSR2	13) SIGPIPE	14) SIGALRM	15) SIGTERM
16) SIGSTKFLT	17) SIGCHLD	18) SIGCONT	19) SIGSTOP	20) SIGTSTP
21) SIGTTIN	22) SIGTTOU	23) SIGURG	24) SIGXCPU	25) SIGXFSZ
26) SIGVTALRM	27) SIGPROF	28) SIGWINCH	29) SIGIO	30) SIGPWR
31) SIGSYS	34) SIGRTMIN	35) SIGRTMIN+1	36) SIGRTMIN+2	37) SIGRTMIN+3
38) SIGRTMIN+4	39) SIGRTMIN+5	40) SIGRTMIN+6	41) SIGRTMIN+7	42) SIGRTMIN+8
43) SIGRTMIN+9	44) SIGRTMIN+10	45) SIGRTMIN+11	46) SIGRTMIN+12	47) SIGRTMIN+13
48) SIGRTMIN+14	49) SIGRTMIN+15	50) SIGRTMAX-14	51) SIGRTMAX-13	52) SIGRTMAX-12
53) SIGRTMAX-11	54) SIGRTMAX-10	55) SIGRTMAX-9	56) SIGRTMAX-8	57) SIGRTMAX-7
58) SIGRTMAX-6	59) SIGRTMAX-5	60) SIGRTMAX-4	61) SIGRTMAX-3	62) SIGRTMAX-2
63) SIGRTMAX-1	64) SIGRTMAX

cpp复制代码#include <signal.h>
typedef void (*sighandler_t)(int);   //函数指针类型

sighandler_t signal(int signum, sighandler_t handler);
函数功能: 注册需要捕获的信号。
函数参数:
int signum  要捕获的信号。 Kill -l
sighandler_t handler :捕获到信号后，执行的函数。

cpp复制代码#include <stdio.h>
#include <time.h>
#include <unistd.h>
#include <sys/time.h>
#include <signal.h>

/*
信号处理函数
*/
void sighandler_func(int sig)
{
    printf("捕获的信号:%d\n",sig);
}

int main(int argc,char **argv)
{
    //注册将要捕获的信号
    signal(SIGINT,sighandler_func);
    while(1)
    {

    }
    return 0;
}

cpp复制代码#include <stdio.h>
#include <time.h>
#include <unistd.h>
#include <sys/time.h>
#include <signal.h>
#include <stdlib.h>
/*
信号处理函数
*/
void sighandler_func(int sig)
{
    printf("捕获的信号:%d\n",sig);
    exit(0); //结束进程
}

int main(int argc,char **argv)
{
    //注册将要捕获的信号
    signal(SIGSEGV,sighandler_func);

    int *p;
    *p=12345;  //给非法内存地址赋值

    while(1)
    {
        
    }
    return 0;
}

cpp复制代码kill -s  <信号名称>  <进程的PID号>
kill -<信号名称>  <进程的PID号>

cpp复制代码[wbyq@wbyq linux_c]$ kill -s SIGINT 18365
[wbyq@wbyq linux_c]$ ps
  PID TTY          TIME CMD
 7481 pts/0    00:00:02 bash
18370 pts/0    00:02:49 a.out
18371 pts/0    00:03:28 a.out
18372 pts/0    00:02:46 a.out
18373 pts/0    00:02:36 a.out
18400 pts/0    00:00:00 ps
[1]   中断                  ./a.out
[wbyq@wbyq linux_c]$ kill -s 2 18370
[wbyq@wbyq linux_c]$ ps
  PID TTY          TIME CMD
 7481 pts/0    00:00:02 bash
18371 pts/0    00:03:39 a.out
18372 pts/0    00:02:56 a.out
18373 pts/0    00:02:47 a.out
18401 pts/0    00:00:00 ps
[2]   中断                  ./a.out
[wbyq@wbyq linux_c]$

[wbyq@wbyq linux_c]$ kill -2 18371

[wbyq@wbyq linux_c]$ kill -9 18372    //强制杀死指定的信号
[wbyq@wbyq linux_c]$ ps
  PID TTY          TIME CMD
 7481 pts/0    00:00:02 bash
18373 pts/0    00:05:31 a.out
18407 pts/0    00:00:00 ps
[4]-  已杀死               ./a.out

cpp复制代码查看后台运行的所有进程:
[wbyq@wbyq linux_c]$ ps    //查看当前终端后台进程
  PID TTY          TIME CMD
 7481 pts/0    00:00:02 bash
18365 pts/0    00:00:54 a.out
18370 pts/0    00:00:04 a.out
18371 pts/0    00:00:04 a.out
18372 pts/0    00:00:05 a.out
18373 pts/0    00:00:03 a.out
18374 pts/0    00:00:00 ps

[wbyq@wbyq linux_c]$ ps -aux   //查看当前系统所有的进程详细信息
wbyq     18365 65.1  0.0   1844   280 pts/0    R    09:19   1:33 ./a.out
wbyq     18370 35.9  0.0   1844   280 pts/0    R    09:20   0:34 ./a.out
wbyq     18371 34.9  0.0   1844   276 pts/0    R    09:20   0:32 ./a.out
wbyq     18372 44.7  0.0   1844   276 pts/0    R    09:20   0:41 ./a.out
wbyq     18373 34.4  0.0   1844   280 pts/0    R    09:20   0:32 ./a.out
wbyq     18375  5.0  0.0   6532  1048 pts/0    R+   09:21   0:00 ps -aux

[wbyq@wbyq linux_c]$ top   //动态查看当前系统的进程详细信息
程序后台运行的方式:
[wbyq@wbyq linux_c]$ ./a.out &

cpp复制代码#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);

java复制代码public class ReentrantLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = 7373984872572414699L;
    private final Sync sync;
    
    public ReentrantLock() {
        sync = new NonfairSync();
    }
    
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
    
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        abstract void lock();
		//......
    }
  
    static final class NonfairSync extends Sync {
		//......
    }

    static final class FairSync extends Sync {
        //......
    }   
}

java复制代码public class Wget {
    public synchronized void doSomething() {
        System.out.println("方法1执行...");
        doOthers();
    }

    public synchronized void doOthers() {
        System.out.println("方法2执行...");
    }
}

java复制代码public class SpinLockDemo {

    AtomicReference<Thread> lock = new AtomicReference<>();

    public void myLock(){
        Thread thread = Thread.currentThread();
        //如果不为空，自旋
        while (!lock.compareAndSet(null,thread)){

        }
    }

    public void myUnlock(){
        Thread thread = Thread.currentThread();
        //解锁后，将锁置为 null
        lock.compareAndSet(thread,null);
    }
}

xml复制代码<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-core</artifactId>
  <version>1.5.3</version>
</dependency>

ini复制代码[users]
xiaochen=123
zhangsan=456

java复制代码public class TestAuthenticator {

    public static void main(String[] args) {
        // 1.创建安全管理器对象
        DefaultSecurityManager securityManager = new DefaultSecurityManager();
        // 2.给安全管理器设置 realm
        securityManager.setRealm(new IniRealm("classpath:shiro.ini"));
        // 3.给 SecurityUtils 全局安全工具类设置安全管理器
        SecurityUtils.setSecurityManager(securityManager);
        // 4.获取认证主体
        Subject subject = SecurityUtils.getSubject();
        // 5.创建令牌
        UsernamePasswordToken token = new UsernamePasswordToken("xiaochen", "123");
        // 6.认证
        try {
            System.out.println("认证状态：" + subject.isAuthenticated());
            subject.login(token);
            System.out.println("认证状态：" + subject.isAuthenticated());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

java复制代码public class TestCustomerRealmAuthenticator {

    public static void main(String[] args) {
        // 1.创建安全管理器对象
        DefaultSecurityManager securityManager = new DefaultSecurityManager();
        // 2.设置自定义realm
        securityManager.setRealm(new CustomerRealm());
        // 3.给 SecurityUtils 全局安全工具类设置安全管理器
        SecurityUtils.setSecurityManager(securityManager);
        // 4.获取认证主体
        Subject subject = SecurityUtils.getSubject();
        // 5.创建令牌
        UsernamePasswordToken token = new UsernamePasswordToken("xiaochen", "123");
        // 6.认证
        try {
            System.out.println("认证状态：" + subject.isAuthenticated());
            subject.login(token);
            System.out.println("认证状态：" + subject.isAuthenticated());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

java复制代码public class CustomerRealm extends AuthorizingRealm {

    // 授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    // 认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        // 1. 在token中获取用户名
        String principal = (String) authenticationToken.getPrincipal();
        // 2. 查询数据库，此处模拟数据库数据
        if ("xiaochen".equals(principal)) {
            // 参数1：正确的用户名
            // 参数2：正确的密码
            // 参数3：提供当前realm的名字
            SimpleAuthenticationInfo simpleAuthenticationInfo
                    = new SimpleAuthenticationInfo("xianchen", "123", this.getName());
            return simpleAuthenticationInfo;
        }
        return null;
    }
}

java复制代码public class TestShiroMD5 {

    public static void main(String[] args) {
        // 1. 使用md5加密
        // 参数1是明文密码
        Md5Hash md5Hash1 = new Md5Hash("123");
        // 打印加密后的密文
        // 结果：202cb962ac59075b964b07152d234b70
        System.out.println(md5Hash1.toHex());
        // 2. 使用md5+salt加密
        Md5Hash md5Hash2 = new Md5Hash("123", "X0*7ps");
        // 8a83592a02263bfe6752b2b5b03a4799
        System.out.println(md5Hash2.toHex());
        // 3. 使用md5+salt+hash散列加密
        Md5Hash md5Hash3 = new Md5Hash("123", "X0*7ps", 1024);
        // e4f9bf3e0c58f045e62c23c533fcf633
        System.out.println(md5Hash3.toHex());
    }
}

java复制代码public class CustomerMd5Realm extends AuthorizingRealm {

    // 授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    // 认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        // 1. 在token中获取用户名
        String principal = (String) authenticationToken.getPrincipal();
        // 2. 查询数据库，此处模拟数据库数据
        if ("xiaochen".equals(principal)) {
            // 参数1：正确的用户名
            // 参数2：正确的密码
            // 参数3：提供当前realm的名字
            // md5
            // return new SimpleAuthenticationInfo(principal, "202cb962ac59075b964b07152d234b70", this.getName());
            // md5+salt
            /*return new SimpleAuthenticationInfo(principal, "8a83592a02263bfe6752b2b5b03a4799", ByteSource.Util.bytes("X0*7ps"), this.getName());*/
        }
        return null;
    }
}

java复制代码public class TestCustomerMd5RealmAuthenticator {

    public static void main(String[] args) {
        // 1.创建安全管理器对象
        DefaultSecurityManager securityManager = new DefaultSecurityManager();
        // 2.设置自定义realm
        CustomerMd5Realm realm = new CustomerMd5Realm();
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        // 使用MD5加密
        hashedCredentialsMatcher.setHashAlgorithmName("md5");
        // 散列次数
        hashedCredentialsMatcher.setHashIterations(1024);
        realm.setCredentialsMatcher(hashedCredentialsMatcher);
        securityManager.setRealm(realm);
        // 3.给 SecurityUtils 全局安全工具类设置安全管理器
        SecurityUtils.setSecurityManager(securityManager);
        // 4.获取认证主体
        Subject subject = SecurityUtils.getSubject();
        // 5.创建令牌
        UsernamePasswordToken token = new UsernamePasswordToken("xiaochen", "123");
        // 6.认证
        try {
            System.out.println("认证状态：" + subject.isAuthenticated());
            subject.login(token);
            System.out.println("认证状态：" + subject.isAuthenticated());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

java复制代码if(subject.hasRole("admin")){
   //操作什么资源
}

java复制代码if(subject.isPermission("user:update:01")){ //资源实例
	//对01用户进行修改
}
if(subject.isPermission("user:update:*")){  //资源类型
	//对01用户进行修改
}

java复制代码public class CustomerMd5Realm extends AuthorizingRealm {

    // 授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        // 获取身份信息
        String primaryPrincipal = (String) principalCollection.getPrimaryPrincipal();
        // 根据身份信息（用户名）从数据库获取当前用户的角色以及权限信息
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        // 将数据库中查询的角色信息赋值给权限对象
        simpleAuthorizationInfo.addRole("admin");
        simpleAuthorizationInfo.addRole("user");
        // 将数据库中查询的权限信息赋值给权限对象
        simpleAuthorizationInfo.addStringPermission("user:*:01");
        simpleAuthorizationInfo.addStringPermission("product:create:02");
        return simpleAuthorizationInfo;
    }

    ...
}

java复制代码public class TestCustomerMd5RealmAuthenticator {

    public static void main(String[] args) {
        
        ...

        // 7. 认证用户进行授权
        if (subject.isAuthenticated()) {
            // 7.1 基于角色权限控制
            boolean hasRole = subject.hasRole("admin");
            System.out.println("角色校验：" + hasRole);
            // 7.2 基于多角色权限控制
            boolean hasAllRoles = subject.hasAllRoles(Arrays.asList("admin", "user"));
            System.out.println("多角色校验：" + hasAllRoles);
            // 7.3 是否具有其中一个角色
            boolean[] booleans = subject.hasRoles(Arrays.asList("admin", "user", "super"));
            for (boolean aBoolean : booleans) {
                System.out.println(aBoolean);
            }
            // 7.4 基于权限字符串的访问控制
            boolean permitted = subject.isPermitted("user:*:01");
            System.out.println("资源权限校验：" + permitted);
            // 7.5 分布具有哪些资源权限
            boolean[] permitted1 = subject.isPermitted("user:*:01", "order:*:10");
            for (boolean b : permitted1) {
                System.out.println(b);
            }
            // 7.6 同时具有哪些资源权限
            boolean permittedAll = subject.isPermittedAll("user:*:01", "product:*");
            System.out.println("多资源权限校验：" + permittedAll);
        }
    }
}

xml复制代码<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring-boot-starter</artifactId>
    <version>1.5.3</version>
</dependency>

java复制代码@Configuration
public class ShiroConfig {

    // 1.创建shiroFilter，负责拦截所有请求
    @Bean
    public ShiroFilterFactoryBean getShiroFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        // 给filter设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        // 配置系统受限资源
        HashMap<String, String> map = new HashMap<>();
        map.put("/user/login", "anon");  // anon设置为公共资源
        map.put("/user/register", "anon");
        map.put("/register.jsp", "anon");
        map.put("/**", "authc"); // authc表示请求这个资源需要认证和授权
        // 默认认证界面路径
        shiroFilterFactoryBean.setLoginUrl("/login.jsp");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        return shiroFilterFactoryBean;
    }

    // 2.创建安全管理器
    @Bean
    public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("realm") Realm realm) {
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        // 给安全管理器设置Realm
        defaultWebSecurityManager.setRealm(realm);
        return defaultWebSecurityManager;
    }

    // 3.创建自定义realm
    @Bean(name = "realm")
    public Realm getRealm() {
        CustomerRealm customerRealm = new CustomerRealm();
        // 修改凭证校验匹配器
        HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
        // 设置加密算法为md5
        credentialsMatcher.setHashAlgorithmName("MD5");
        // 设置散列次数
        credentialsMatcher.setHashIterations(1024);
        customerRealm.setCredentialsMatcher(credentialsMatcher);
        return customerRealm;
    }
}

java复制代码public class CustomerRealm extends AuthorizingRealm {

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        String principal = (String) authenticationToken.getPrincipal();
        UserSev userSev = (UserSev) ApplicationContextUtils.getBean("userSev");
        User user = userSev.findByUsername(principal);
        if (user != null) {
            return new SimpleAuthenticationInfo(user.getUsername(), user.getPassword(),
                    ByteSource.Util.bytes(user.getSalt()), this.getName());
        }
        return null;
    }
}

java复制代码@Controller
@RequestMapping("user")
public class UserCon {

    @Autowired
    private UserSev userSev;

    @RequestMapping("logout")
    public String logout(String username, String password) {
        // 获取主体对象
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        return "redirect:/login.jsp";
    }

    @RequestMapping("login")
    public String login(String username, String password) {
        // 获取主体对象
        Subject subject = SecurityUtils.getSubject();
        try {
            subject.login(new UsernamePasswordToken(username, password));
            return "redirect:/index.jsp";
        } catch (UnknownAccountException e) {
            System.out.println("用户名错误");
        } catch (IncorrectCredentialsException e) {
            System.out.println("密码错误");
        }
        return "redirect:/index.jsp";
    }

    @RequestMapping("register")
    public String register(User user) {
        try {
            userSev.register(user);
        } catch (Exception e) {
            return "redirect:/register.jsp";
        }
        return "redirect:/login.jsp";
    }
}

java复制代码@Service
public class UserSev {

    @Autowired
    private UserDao userDao;

    public void register(User user) {
        // 处理业务调用dao
        // 明文密码进行 md5 + salt + hash散列
        String salt = SaltUtils.getSalt();
        user.setSalt(salt);
        Md5Hash md5Hash = new Md5Hash(user.getPassword(), salt, 1024);
        user.setPassword(md5Hash.toHex());
        userDao.save(user);
    }

    public User findByUsername(String username) {
        return userDao.findByUserName(username);
    }
}

jsp复制代码<%@taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>
<shiro:hasAnyRoles name="user,admin">
    <li><a href="">用户管理</a>
        <ul>
            <shiro:hasPermission name="user:add:*">
                <li><a href="">添加</a></li>
            </shiro:hasPermission>
            <shiro:hasPermission name="user:delete:*">
                <li><a href="">删除</a></li>
            </shiro:hasPermission>
            <shiro:hasPermission name="user:update:*">
                <li><a href="">修改</a></li>
            </shiro:hasPermission>
            <shiro:hasPermission name="user:find:*">
                <li><a href="">查询</a></li>
            </shiro:hasPermission>
        </ul>
    </li>
</shiro:hasAnyRoles>
<shiro:hasRole name="admin">
    <li><a href="">商品管理</a></li>
    <li><a href="">订单管理</a></li>
    <li><a href="">物流管理</a></li>
</shiro:hasRole>

java复制代码@RequestMapping("save")
public String save(){
  System.out.println("进入方法");
  //获取主体对象
  Subject subject = SecurityUtils.getSubject();
  //代码方式
  if (subject.hasRole("admin")) {
    System.out.println("保存订单!");
  }else{
    System.out.println("无权访问!");
  }
  //基于权限字符串
  //....
  return "redirect:/index.jsp";
}

java复制代码@RequiresRoles(value={"admin","user"})//用来判断角色  同时具有 admin user
@RequiresPermissions("user:update:01") //用来判断权限字符串
@RequestMapping("save")
public String save(){
  System.out.println("进入方法");
  return "redirect:/index.jsp";
}

java复制代码public class CustomerRealm extends AuthorizingRealm {
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        //获取身份信息
        String primaryPrincipal = (String) principals.getPrimaryPrincipal();
        System.out.println("调用授权验证: "+primaryPrincipal);
        //根据主身份信息获取角色 和 权限信息
        UserService userService = (UserService) ApplicationContextUtils.getBean("userService");
        User user = userService.findRolesByUserName(primaryPrincipal);
        //授权角色信息
        if(!CollectionUtils.isEmpty(user.getRoles())){
            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
            user.getRoles().forEach(role->{
                simpleAuthorizationInfo.addRole(role.getName());
                //权限信息
                List<Perms> perms = userService.findPermsByRoleId(role.getId());
                if(!CollectionUtils.isEmpty(perms)){
                    perms.forEach(perm->{
                        simpleAuthorizationInfo.addStringPermission(perm.getName());
                    });
                }
            });
            return simpleAuthorizationInfo;
        }
        return null;
    }
}

xml复制代码<!--引入shiro和ehcache-->
<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-ehcache</artifactId>
  <version>1.5.3</version>
</dependency>

java复制代码@Bean
public Realm getRealm(){
    CustomerRealm customerRealm = new CustomerRealm();
    //修改凭证校验匹配器
    HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
    //设置加密算法为md5
    credentialsMatcher.setHashAlgorithmName("MD5");
    //设置散列次数
    credentialsMatcher.setHashIterations(1024);
    customerRealm.setCredentialsMatcher(credentialsMatcher);

    //开启缓存管理
    customerRealm.setCacheManager(new EhCacheManager());
    customerRealm.setCachingEnabled(true);//开启全局缓存
    customerRealm.setAuthenticationCachingEnabled(true);//认证认证缓存
    customerRealm.setAuthenticationCacheName("authenticationCache");
    customerRealm.setAuthorizationCachingEnabled(true);//开启授权缓存
    customerRealm.setAuthorizationCacheName("authorizationCache");
    return customerRealm;
}

xml复制代码<!--redis整合springboot-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

properties复制代码spring.redis.port=6379
spring.redis.host=localhost
spring.redis.database=0

java复制代码public class RedisCacheManager implements CacheManager {
    @Override
    public <K, V> Cache<K, V> getCache(String cacheName) throws CacheException {
        System.out.println("缓存名称: "+cacheName);
        return new RedisCache<K,V>(cacheName);
    }
}

java复制代码public class RedisCache<K,V> implements Cache<K,V> {

    private String cacheName;

    public RedisCache() {
    }

    public RedisCache(String cacheName) {
        this.cacheName = cacheName;
    }

    @Override
    public V get(K k) throws CacheException {
        System.out.println("获取缓存:"+ k);
        return (V) getRedisTemplate().opsForHash().get(this.cacheName,k.toString());
    }

    @Override
    public V put(K k, V v) throws CacheException {
        System.out.println("设置缓存key: "+k+" value:"+v);
        getRedisTemplate().opsForHash().put(this.cacheName,k.toString(),v);
        return null;
    }

    @Override
    public V remove(K k) throws CacheException {
        return (V) getRedisTemplate().opsForHash().delete(this.cacheName,k.toString());
    }

    @Override
    public v remove(k k) throws CacheException {
        return (v) getRedisTemplate().opsForHash().delete(this.cacheName,k.toString());
    }

    @Override
    public void clear() throws CacheException {
        getRedisTemplate().delete(this.cacheName);
    }

    @Override
    public int size() {
        return getRedisTemplate().opsForHash().size(this.cacheName).intValue();
    }

    @Override
    public Set<k> keys() {
        return getRedisTemplate().opsForHash().keys(this.cacheName);
    }

    @Override
    public Collection<v> values() {
        return getRedisTemplate().opsForHash().values(this.cacheName);
    }

    private RedisTemplate getRedisTemplate(){
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }


    // 封装获取 redisTemplate
    private RedisTemplate getRedisTemplate(){
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

java复制代码 // 自定义 salt 实现，实现序列化接口
 public class MyByteSource extends SimpleByteSource implements Serializable {
     public MyByteSource(String string) {
         super(string);
     }
 }

java复制代码public class MyByteSource implements ByteSource, Serializable {
  
    private  byte[] bytes;
    private String cachedHex;
    private String cachedBase64;

    //加入无参数构造方法实现序列化和反序列化
    public MyByteSource(){

    }

    public MyByteSource(byte[] bytes) {
        this.bytes = bytes;
    }

    public MyByteSource(char[] chars) {
        this.bytes = CodecSupport.toBytes(chars);
    }

    public MyByteSource(String string) {
        this.bytes = CodecSupport.toBytes(string);
    }

    public MyByteSource(ByteSource source) {
        this.bytes = source.getBytes();
    }

    public MyByteSource(File file) {
        this.bytes = (new MyByteSource.BytesHelper()).getBytes(file);
    }

    public MyByteSource(InputStream stream) {
        this.bytes = (new MyByteSource.BytesHelper()).getBytes(stream);
    }

    public static boolean isCompatible(Object o) {
        return o instanceof byte[] || o instanceof char[] || o instanceof String || o instanceof ByteSource || o instanceof File || o instanceof InputStream;
    }

    public byte[] getBytes() {
        return this.bytes;
    }

    public boolean isEmpty() {
        return this.bytes == null || this.bytes.length == 0;
    }

    public String toHex() {
        if (this.cachedHex == null) {
            this.cachedHex = Hex.encodeToString(this.getBytes());
        }

        return this.cachedHex;
    }

    public String toBase64() {
        if (this.cachedBase64 == null) {
            this.cachedBase64 = Base64.encodeToString(this.getBytes());
        }

        return this.cachedBase64;
    }

    public String toString() {
        return this.toBase64();
    }

    public int hashCode() {
        return this.bytes != null && this.bytes.length != 0 ? Arrays.hashCode(this.bytes) : 0;
    }

    public boolean equals(Object o) {
        if (o == this) {
            return true;
        } else if (o instanceof ByteSource) {
            ByteSource bs = (ByteSource)o;
            return Arrays.equals(this.getBytes(), bs.getBytes());
        } else {
            return false;
        }
    }

    private static final class BytesHelper extends CodecSupport {
        private BytesHelper() {
        }

        public byte[] getBytes(File file) {
            return this.toBytes(file);
        }

        public byte[] getBytes(InputStream stream) {
            return this.toBytes(stream);
        }
    }
}

csharp复制代码public static int Main()
{
    MaoniType o = new MaoniType(128, 256);
    Console.ReadLine();
    // 其它乱七八糟的代码
    return 0;
}

csharp复制代码public class MaoniType
{
        public MaoniType(int a, int b)
        {
            A = a;
            B = b;
        }

        public int A { get; set; }
        public int B { get; set; }
}

shell复制代码0:007> .load C:\Users\webmote.dotnet\sos\sos.dll
0:007> !dumpheap -stat
Statistics:
              MT    Count    TotalSize Class Name
00007ffc77c37598        1           24 System.IO.SyncTextReader
00007ffc77c33478        1           24 System.Threading.Tasks.Task+<>c
00007ffc77c1ca70        1           24 System.IO.Stream+NullStream
00007ffc77c13798        1           24 ConsoleApp6.MaoniType
...
[omitted]

00007ffc77bd7f48       28         1160 System.SByte[]
00007ffc77bd8410        4         3596 System.Int32[]
00007ffc77c1d3c8        3         4178 System.Byte[]
00007ffc77b2b578        8        18216 System.Object[]
00007ffc77c33898        3        33356 System.Char[]
00007ffc77bdd698       82        35610 System.String
Total 208 objects

shell复制代码0:007> !DumpHeap /d -mt 00007ffc77c13798
         Address               MT     Size
000002470000c0c8 00007ffc77c13798       24     

Statistics:
              MT    Count    TotalSize Class Name
00007ffc77c13798        1           24 ConsoleApp6.MaoniType
Total 1 objects

shell复制代码姓名： Maoni/莫妮
尺寸： 24
起点：c0c8 [000002470000c0c8]
个数：1个
表索引：[00007ffc77c13798]

shell复制代码0:007> !eeheap -gc
Number of GC Heaps: 1
generation 0 starts at 0x0000024700001030
generation 1 starts at 0x0000024700001018
generation 2 starts at 0x0000024700001000
ephemeral segment allocation context: none
         segment             begin         allocated         committed    allocated size    committed size
0000024700000000  0000024700001000  00000247000173C8  0000024700022000  0x163c8(91080)  0x21000(135168)
Large object heap starts at 0x0000024710001000
         segment             begin         allocated         committed    allocated size    committed size
0000024710000000  0000024710001000  0000024710001018  0000024710002000  0x18(24)  0x1000(4096)
Pinned object heap starts at 0x0000024718001000
0000024718000000  0000024718001000  0000024718005420  0000024718012000  0x4420(17440)  0x11000(69632)
Total Allocated Size:              Size: 0x1a800 (108544) bytes.
Total Committed Size:              Size: 0x22000 (139264) bytes.
------------------------------
GC Allocated Heap Size:    Size: 0x1a800 (108544) bytes.
GC Committed Heap Size:    Size: 0x22000 (139264) bytes.

shell复制代码0:007> dq 000002470000c0c8-8 l3
00000247`0000c0c0  00000000`00000000 00007ffc`77c13798
00000247`0000c0d0  00000100`00000080

csharp复制代码public static int Main()
{
    MaoniType o = new MaoniType(128, 256);
    GCHandle h = GCHandle.Alloc(o, GCHandleType.Weak);
    GC.Collect();
    Console.WriteLine("Collect called, h.Target is {0}",
            (h.Target == null) ? "collected" : "not collected");
    return 0;
}

csharp复制代码[MethodImpl(MethodImplOptions.NoInlining)]
    public static void TestLifeTime()
    {
        MaoniType o = new MaoniType(128, 256);
        h = GCHandle.Alloc(o, GCHandleType.Weak);
    }

    public static int Main()
    {
        TestLifeTime();
        GC.Collect();
        Console.WriteLine("Collect called, h.Target is {0}",
                (h.Target == null) ? "collected" : "not collected");

        return 0;
    }

java复制代码	// 合并
    public void union(Node node1, Node node2) {
        // 找到两个节点的父节点
        Node node1Parent = getParentNode(node1);
        Node node2Parent = getParentNode(node2);
        // 看看是不是一个父亲
        if (node1Parent != node2Parent) {
            // node1、node2父亲的节点数量
            int size1 = size.get(node1Parent);
            int size2 = size.get(node2Parent);
            // 谁的节点多，少的就挂在多的下面，进行合并
            if (size1 >= size2) {
                parent.put(node1Parent, node2Parent);
                size.put(node1Parent, size1 + size2);
                size.remove(node2Parent);
            } else {
                parent.put(node2Parent, node1Parent);
                size.put(node2Parent, size1 + size2);
                size.remove(node2Parent);
            }
        }
    }

java复制代码	public boolean isSame(Node node1, Node node2) {
        return getParentNode(node1) == getParentNode(node2);
    }

    public Node getParentNode(Node node) {
        // 为了路径压缩
        Stack<Node> stack = new Stack<>();
        while (parent.get(node) != node) {
            stack.add(node);
            node = parent.get(node);
        }
        while (!stack.isEmpty()) {
            parent.put(stack.pop(), node);
        }
        return node;
    }

java复制代码	// 赋予初始值
    public void makeSets(Collection<Node> list) {
        for (Node node : list) {
        	// 初始时，每个节点的父节点均是自己，集合的数量为1
            parent.put(node, node);
            size.put(node, 1);
        }
    }

java复制代码 	public static class EdgeComparator implements Comparator<Edge> {

        @Override
        public int compare(Edge o1, Edge o2) {
            return o1.weight - o2.weight;
        }
    }

java复制代码	public static Set<Edge> kruskalMST(Graph graph) {
        Union union = new Union();
        // 初始化并查集
        union.makeSets(graph.nodes.values());
		// 建堆，按照边的权重进行排序
        PriorityQueue<Edge> priorityQueue = new PriorityQueue<>(new EdgeComparator());
        // 放入边
        for (Edge edge : graph.edges) {
            priorityQueue.add(edge);
        }
        Set<Edge> edges = new HashSet<>();
        // 从最小的开始
        while (!priorityQueue.isEmpty()) {
            Edge edge = priorityQueue.poll();
            // 看一下是否是一个集合的
            if (!union.isSame(edge.from, edge.to)) {
            	// 可以选取这条边，合并这两个点
                edges.add(edge);
                union.union(edge.from, edge.to);
            }
        }
        return edges;
    }

java复制代码//LongAdder是Striped64的子类
public class LongAdder extends Striped64 implements Serializable {
}

java复制代码abstract class Striped64 extends Number {
    /**
     * Padded variant of AtomicLong supporting only raw accesses plus CAS.
     *
     * JVM intrinsics note: It would be possible to use a release-only
     * form of CAS here, if it were provided.
     */
    @sun.misc.Contended static final class Cell {
        volatile long value;
        Cell(long x) { value = x; }
        final boolean cas(long cmp, long val) {
            return UNSAFE.compareAndSwapLong(this, valueOffset, cmp, val);
        }

        // Unsafe mechanics
        private static final sun.misc.Unsafe UNSAFE;
        private static final long valueOffset;
        static {
            try {
                UNSAFE = sun.misc.Unsafe.getUnsafe();
                Class<?> ak = Cell.class;
                valueOffset = UNSAFE.objectFieldOffset
                        (ak.getDeclaredField("value"));
            } catch (Exception e) {
                throw new Error(e);
            }
        }
    }

    /** Number of CPUS, to place bound on table size */
    //表示当前计算机CPU数量，什么用？ 控制cells数组长度的一个关键条件
    static final int NCPU = Runtime.getRuntime().availableProcessors();

    /**
     * Table of cells. When non-null, size is a power of 2.
     * cells数组
     */
    transient volatile Cell[] cells;

    /**
     * Base value, used mainly when there is no contention, but also as
     * a fallback during table initialization races. Updated via CAS.
     * 没有发生过竞争时，数据会累加到 base上 | 当cells扩容时，需要将数据写到base中
     */
    transient volatile long base;

    /**
     * Spinlock (locked via CAS) used when resizing and/or creating Cells.
     * 初始化cells或者扩容cells都需要获取锁，0 表示无锁状态，1 表示其他线程已经持有锁了
     */
    transient volatile int cellsBusy;

    /**
     * Package-private default constructor
     */
    Striped64() {
    }

    /**
     * CASes the base field.
     * 通过修改base中的值
     */
    final boolean casBase(long cmp, long val) {
        return UNSAFE.compareAndSwapLong(this, BASE, cmp, val);
    }

    /**
     * CASes the cellsBusy field from 0 to 1 to acquire lock.
     * 通过CAS方式获取锁，即将CELLSBUSY改成1，表示获取到了锁
     */
    final boolean casCellsBusy() {
        return UNSAFE.compareAndSwapInt(this, CELLSBUSY, 0, 1);
    }

    /**
     * Returns the probe value for the current thread.
     * Duplicated from ThreadLocalRandom because of packaging restrictions.
     *
     * 获取当前线程的Hash值
     */
    static final int getProbe() {
        return UNSAFE.getInt(Thread.currentThread(), PROBE);
    }

    /**
     * Pseudo-randomly advances and records the given probe value for the
     * given thread.
     * Duplicated from ThreadLocalRandom because of packaging restrictions.
     *
     * 重置当前线程的Hash值
     */
    static final int advanceProbe(int probe) {
        probe ^= probe << 13;   // xorshift
        probe ^= probe >>> 17;
        probe ^= probe << 5;
        UNSAFE.putInt(Thread.currentThread(), PROBE, probe);
        return probe;
    }
}