高并发编程long和double都是64位,每次只能32位读两次,加上volatile,就读写原子. 还有内存屏障的作用

高并发

为什么多线程

进程之间不能共享内存,而线程之间可以共享内存(堆内存)
创建进程时,需要重新分配系统资源,创建线程代价很小,所有多并发时候,效率更高
java本身内置多线程的功能支持

线程和进程分别如何通信

进程依靠IPC资源比如管道pipes 套接字sockets
线程依靠jvm的Api wait() notify() notifyall()

线程活锁

相互让出资源的竞争给对方,不眠不休

多线程死锁的四个必要条件

互斥请求与保持不剥夺循环等待

如何避免死锁

	指定获取锁的顺序

线程的六状态

新建
可运行
阻塞
等待
计时等待
终止

高并发编程-JUC

java.util.concurrent 简称JUC包

sleep() wait() wait(n)

答:

sleep() wait() wait(n) Thread类 Object类 Object 阻塞阻塞阻塞n毫秒

Synchronized关键字

答:底层实现

1.	进入时,执行monitorenter,计数器+1,离开时monitorexit,计数器-1,wait notify notifyall 都必须在Synchronized中使用,因为monitor可以被Synchronized创建,因为调用它们之前,必须拿到该对象的monitor对象先.

2.	计数器为0,锁空闲,可占用,否则线程等待

含义( monitor机制):

Synchronized锁封装了多个锁,可以在线程竞争锁的情况下,锁等级发生由低到高的切换,[偏向锁-轻量锁-自旋锁-对象锁(重量锁)]

volatile关键字能使一个非原子操作变成原子操作

答:
1. long和double都是64位,每次只能32位读两次,加上volatile,就读写原子.
2. 还有内存屏障的作用,例如在分布式框架的应用,写一个volatile变量时,java内存模型会加一个写屏障,其他线程可以看到你的修改值,同样,读也有读屏障.

ThreadLocal和ThreadLocalMap

答:

1.	ThreadLocal内部会维护一个ThreadLocalMap对象,包含了一个个Entry,k:线程的hash值,v:线程的数组存储的索引

2.	Entry对k是弱引用,对v是强引用,没有强引用,一般活不过第一次GC

线程池的了解

答:

1.	java.util.concurrent.ThreadPoolExecutor,客户端调用(Runnable task)提交任务.线程池内部维护的线程数量就是当前线程池大小.还有MaxNumPoolSize 最大线程池大小,corePoolsize 核心线程大小,

由大小决定阻塞还是拒绝

	面试官:为什么使用线程池

		答:	

			1.	减少线程创建和销毁的开销,保证每个线程都能被重复利用,异步执行任务

			2.	根据系统承受能力,动态调整线程池总工作线程的数目,放置消耗太多内存导致服务器累趴的线程

	面试官:核心线程池内部了解吗		

		答: 	不管是newFixedThreadPool(),newSingleThreadExecutor()还是newCachedThreadPool(),内部实现均使用了ThreadPoolExecutor,基于它的封装罢了

public ThreadPoolExecutor(
	int corePoolSize
	int maxinumPoolSize
	long KeepAliveTime
	TimeUnit unit
	BlockingQueue<Runnable> workQueue //
	ThreadFactory threadfactory	//创建线程
	RejectedExecutionHandler handler  //拒绝策略
)

Atomic关键字

答: 基本数据类型以原子操作自增自减等操作

创建线程的两种方式

答:

    方式	            	-:

实现Runnable接口可实现其他,可继承其他, 操作稍复杂多线程可共享资源继承Thread类不可拥有其他直接父类操作简单多线程无法共享资源

```
 run()&start()	
```
答: run()是普通方法,start()需要创建新线程
线程优先级

答: 1-10级别默认5,高并发中线程调度靠优先级不一定OK,还是得应用层控制线程调度
如何停止一个线程

答: jdk1.0的stop suspend resume方法,由于可能导致死锁全部弃用,后续没有终止线程的API可以用其他办法:--------volatile不布尔变量在run()中控制
忙循环

答: 让线程空循环,不放弃线程的cpu资源,多核系统中常用,减少资源申请的开销
10个线程和2个线程的同步代码哪个难写

答: 一样,同步代码和线程数量相互独立
伪共享

答: 线程的不同变量在一个64位缓存行[内存的多级缓存概念]上,修改其中一个变量,导致变量失效,则缓存行失效,其他变量需要重新从内存读取.
生产消费 wait&notify

代码有bug,以后再改吧

用java写一个线程安全的单例模式

答:

普通饿汉式单例

//
public class singleton{
    //类加载的时候,对象创建OK
	private Singleton  instance new Singleton();
    private Singleton(){}
    //其实这里static已经用静态代码块实现单例了,上面可以不用new
 	public static Singleton getInstance(){
       return instance;
   }
}

多线程安全的饿汉式单例

public class Singleton{
    //对象未分配内存,暂不创建
    private Singleton instance;
    private Singleton(){}
    public static  sychronized Singleton getInstance(){
        if(instance==null){
            instance=new Singleton();            
        }
        return instance;
    }  
}

静态内部类的方式创建单例

public class Singleton{
    private Singleton(){}
    private static class Singleton SingletonHolder(){
        private static Singleton singleton=new Singleton;
    }  
    public static Singleton getInstance(){
        return Singleton.SingletonHolder();
    }
}

双重校验锁

public class Singleton{
    //对象未分配内存,暂不创建
    private Singleton instance;
    private Singleton(){}
    public static  Singleton getInstance(){
        if(instance==null){
            sychronized(Singleto.class){
            //线程可能同时获取锁对象,都拿到iunstance==null,故增加一重校验,
            if(instance==null){
            instance=new Singleton();
            }
        }
    return instance;
    }  
}

参见1的注释

枚举类的单例模式

class MySingleton {}
public class ClassFactory{
    private enum MyEnumSingleton{  
        singletonFactory;  
        private MySingleton instance;  
        //枚举类的构造方法在类加载是被实例化  
        private MyEnumSingleton(){ instance = new MySingleton();}  
        public MySingleton getInstance(){return instance;}  
    }   
    public static MySingleton getInstance(){  
        return MyEnumSingleton.singletonFactory.getInstance();
    }  
}