1.@RestController与@Controller的区别
@RestController的官方解释：
A convenience annotation that is itself annotated with {@link Controller @Controller} and {@link ResponseBody @ResponseBody}。
也就是说它相当于是两部分：一部分@Controller，一部分@ResponseBody。它被视为@RequestMapping和@ResponseBody的语义。如果配置了适当的{@code HandlerMapping}-{@code HandlerAdapter}对(这是MVC Java配置和MVC名称空间中的缺省值)，则处理{@code @RestController}。但它不支持{@code @RestController}-{@code AnnotationMethodHandlerAdapter}对，它们也是不推荐的。@Controller的官方解释：
This annotation serves as a specialization of {@link Component @Component},allowing for implementation classes to be autodetected through classpath scanning.It is typically used in combination with annotated handler methods based on the {@link org.springframework.web.bind.annotation.RequestMapping} annotation.
该注释被当作一个专业的组件，允许通过类路径自动扫描实现类。它通常和RequestMapping绑定使用。2.wait和sleep的区别：
sleep()是使线程暂停执行一段时间的方法。wait()也是一种使线程暂停执行的方法。例如，当线程执行wait()方法时候，会释放当前的锁，然后让出CPU，进入等待状态。并且可以调用notify（）方法或者notifyAll（）方法通知正在等待的其他线程。notify（）方法仅唤醒一个线程（等待队列中的第一个线程）并允许他去获得锁。notifyAll（）方法唤醒所有等待这个对象的线程并允许他们去竞争获得锁。具体区别如下：
1) 原理不同。sleep()方法是Thread类的静态方法，是线程用来控制自身流程的，他会使此线程暂停执行一段时间，而把执行机会让给其他线程，等到计时时间一到，此线程会自动苏醒。例如，当线程执行报时功能时，每一秒钟打印出一个时间，那么此时就需要在打印方法前面加一个sleep()方法，以便让自己每隔一秒执行一次，该过程如同闹钟一样。而wait()方法是object类的方法，用于线程间通信，这个方法会使当前拥有该对象锁的进程等待，直到其他线程调用notify（）方法或者notifyAll（）时才醒来，不过开发人员也可以给他指定一个时间，自动醒来。
2) 对锁的 处理机制不同。由于sleep()方法的主要作用是让线程暂停执行一段时间，时间一到则自动恢复，不涉及线程间的通信，因此，调用sleep()方法并不会释放锁。而wait()方法则不同，当调用wait()方法后，线程会释放掉他所占用的锁，从而使线程所在对象中的其他synchronized数据可以被其他线程使用。
3) 使用区域不同。wait()方法必须放在同步控制方法和同步代码块中使用，sleep()方法则可以放在任何地方使用。sleep()方法必须捕获异常，而wait()、notify（）、notifyAll（）不需要捕获异常。在sleep的过程中，有可能被其他对象调用他的interrupt（），产生InterruptedException。由于sleep不会释放锁标志，容易导致死锁问题的发生，因此一般情况下，推荐使用wait（）方法。
3.Look的类型
ReentrantLock：- 公平锁/非公平锁
- 可重入锁
- 独享锁/共享锁
- 互斥锁/读写锁
- 乐观锁/悲观锁
- 分段锁
- 偏向锁/轻量级锁/重量级锁
- 自旋锁
4.CAS机制：
package Thread;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 了解CAS机制，扫清盲点,
*什么是CAS？
* CAS=Compare And Swap
* 三个基本操作数：内存地址v，旧的预期值A，要更改的新值B
* 更新一个变量的时候，只有当预期值A和内存地址v当中的实际值相同时，才会将内存地址v对应的值修改为B。、
*线程在提交更新值之前，会将当前的旧址与内存地址v的实际值进行比较，如果不相同，则提示提交失败，线程就会
* 在此时进行重新获取，这个过程叫做自旋。
* 对比synchronize，CAS是一个乐观锁机制，乐观的认为程序中的并发问题并没有太过严重。
* 除了在Atomic类里面用到CAS，还在很多LOCK实现的底层用到CAS
* 缺点：
* 1.CPU开销比较大：在并发量较高的情况下，如果一个线程反复更新一个变量，而又反复更新不成功，会给CPU造成很大的压力
* 2.不能保证代码块的原子性操作：CAS只能保证一个变量的原子性操作，而不能保证代码块的原子性操作，如果需要多个变量的
* 共同原子性操作的更新，就不得不使用synchronize。
* 3.ABA问题：一个变量的值从A变成了B又从B变成了A
* 解决办法：加一个版本号在A上，如果最后提交的时候A的版本号和当前的一致，则提交成功，否则提交失败
* CAS自旋：
* 1.获取当前值；
* 2.当前值加1，计算出目标值；
* 3.进行CAS操作，如果成功跳出循环，否则重复上述操作
* public final int incrementAndGet() {
*
* for (;;) {
*
* int current = get();
*
* int next = current + 1;
*
* if (compareAndSet(current, next))
*
* return next;
*
* }
*
* }
*
* private volatile int value; public final int get() {
*
* return value;
*
* }
* //关于compareAndSet的底层实现
* public final boolean compareAndSet(int expect,int update){
* return unsafe.compareAndSwapInt(this,valueOffset,expect,update);
* }
* private static final Unsafe unsafe = Unsafe.getUnsafe();
* private static final long valueOffset;
* static{
* try{
* valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));
* }catch(Exception ex){
* throw new Error(ex);
* }
* }
* unsafe为我们提供了硬件级别的原子操作
* 至于valueOffset对象，是通过unsafe.objectFieldOffset方法得到，所代表的是AtomicInteger对象value
* 成员变量在内存中的偏移量。我们可以简单地把valueOffset理解为value变量的内存地址。
* 而unsafe的compareAndSwapInt方法参数包括了这三个基本元素：valueOffset参数代表了V，expect参数代表了A，update参数代表了B。
* 正是unsafe的compareAndSwapInt方法保证了Compare和Swap操作之间的原子性操作。
*
* */
public class CASDemo {
public static int count = 0;
public static int count1 = 0;
private static AtomicInteger count2 = new AtomicInteger(0);
public static void sample(){
/**
* 先看一个例子,
* 因为线程是不安全的，所以导致结果count可能会小于200
* */
//开启两个线程
for(int i=0;i<2;i++){
new Thread (
new Runnable() {
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
//每个线程当中让count值自增100次
for (int j = 0; j < 100; j++) {
count++;
}
}
}).start();
}
try{
Thread.sleep(2000);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("count="+count);
}
public static void sample2(){
//给上一个例子上加上synchronize关键字
//开启两个线程,加了同步锁之后，count1++变成了原子操作，代码实现了线程安全，结果变成200
//但是明显感觉性能变慢了
long start = System.currentTimeMillis();
for(int i=0;i<2;i++){
new Thread (
new Runnable() {
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
//每个线程当中让count值自增100次
for (int j = 0; j < 100; j++) {
synchronized (CASDemo.class){
count1++;
}
}
}
}).start();
}
try{
Thread.sleep(2000);
}catch (InterruptedException e){
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("count1="+(end-start)+":"+count1);
}
public static void sample3(){
//使用原子操作类,记录下时间
//Atomic类的底层实现了CAS机制
long start = System.currentTimeMillis();
for(int i=0;i<2;i++){
new Thread (
new Runnable() {
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
//每个线程当中让count值自增100次
for (int j = 0; j < 100; j++) {
count2.incrementAndGet();
}
}
}).start();
}
try{
Thread.sleep(2000);
}catch (InterruptedException e){
e.printStackTrace();
}
Long end = System.currentTimeMillis();
System.out.println("count2="+(end-start)+":"+count2.get());
}
public static void main(String arg[]){
sample();
sample2();
sample3();
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
