自定义线程池

把main看作任务的生产者，把线程看作任务的消费者，这时候模型就建立出来了
于是我们需要一个缓冲区，采取消费正生产者模式，然后让消费者不断消费，并在适当的时候创建新的消费者，如果所有任务都做完了，就取消消费者

不可变就是线程安全

如String

拷贝构造函数

之间赋值

char[]构造

拷贝一份(保护性拷贝)

子串

如果下标起点和母串起点相同，则之间引用过去，否则保护性拷贝(不明白为啥不共用)

享元模式

最小化内存的使用，共用内存

包装类

valueOf, 比如Long如果在-128到127之间，就使用一个cache数组，又如String串池，BigDecimal和BigInteger的某些数组

保护

千万要注意这些类的函数组合起来操作就不一定安全了，需要用原子引用类来保护

CAS

compareAndSet(prev,next);无锁，无阻塞

为什么效率高

失败的话会重新尝试，但是锁会进行上下文切换，代价大

原子整形

AtomicInteger

1
2
3

incrementAndGet();
getAndAdd(5);
updateAndGet(value -> value*10);

JMM

Java Memory Model

• 原子性: 保证指令不会收到线程上下文切换的影响
• 可见性: 保证指令不会受到cpu缓存的影响
• 有序性: 保证指令不会受到cpu指令并行优化的影响

synchronized

锁住对象，放在静态方法前为锁类，放在普通方法前为锁类的对像。使用管程实现

线程安全类

String, Integer, StringBuffer,Random,Vector,Hashtable,juc;

加锁

把对象头的hash、Age和对象的指针放进自己的栈中，让对象头的hash、Age,位置指向自己的栈，
这时候来了另一个线程也想拿到锁，但是他肯定会失败，失败以后他就申请重量级锁，让对象头再次改变为指向管程，
当原来当线程想要释放锁的时候，依然使用cas，但是肯定失败，他发现现在的锁已经变成了重量级锁了。

栈

每个线程都有自己的栈，

线程上下文切换

• CPU时间片用完
• gc
• 有更高优先级的线程要运行
• 线程自己sleep,yield,wait,join,park,synchronized,lock

使用Tread创建线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

package com.wsx.test;

import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ThreadTest {
    @Test
    public void test1() {
        final Logger logger = LoggerFactory.getLogger(ThreadTest.class);
        Thread thread = new Thread() {
            @Override
            public void run() {
                logger.debug("running");
            }
        };
        thread.setName("t1");
        thread.start();
        logger.debug("running");
    }
}

Where from

快来点我

进程

一个活动的程序，是程序的实例，大部分程序可以运行多个实例，有的程序只可以运行一个实例

spring支持的事务

似乎都是关于数据库的，可能也是我的水平问题，不知道其他的东西
大概需要实现两个，一个commit，另一个是rollback
事务是基于AOP实现的