JAVA 高并发

写在前面

一切技术都是纸老虎，技术就是一层膜，捅破了就什么也不是
多线程两种完成方式
继承Thread类，完成run办法将需求多线程启动的功用代码放在run办法内该方式有isinterrupted标志位，
能够依据该标志位在另一个可以获取到该线程的代码块中that.interrupt完成中缀，但是能否真的中缀则由that线程决议
完成runnable接口，覆写run办法将需求多线程启动的功用代码放在run办法内，留意这里没有isInterrupted标志位
实践上在一个线程中中止另一个线程能够用concurrent包中的cancel办法，这个跟python几乎一毛一样啊啊啊
ExecutorService接口下固定大小线程池(Fixed)，动态变化(Cached)，以及只要单个(Single)线程的线程池
//t1.start()永远运用start–》start0（本中央法）去启动线程而非调用run办法

//这里记得t1.join()是等候t1线程执行完成才会继续往下执行
//t1.setDaemon(true)设置为守护线程，也就是不那么重要的，JVM在一切非守护线程执行完成后就会退出，渣滓回收就是一个守护线程
//固然我们以后运用concurrent包来停止并发，但是根底原理一定要控制结实
//进程六种状态
NEW：新建状态刚刚创立出来，还没有调用start办法之前的状态。
RUNNABLE:可运转状态，可能正在执行，也可能不是正在执行，只要在该种状态下的线程才有资历抢CPU。
BLOCKED:锁阻塞状态线程要等候另一个线程释放锁对象。
WAITING：无限等候线程调用了wait()办法进入的状态，需求其它线程调用notify办法唤醒。
TIMED_WAITING:计时等候状态线程调用了sleep办法获wait（longtime）办法进入的状态。
TERMINATED:死亡状态线程任务执行终了或调用了stop办法。
Thread常用办法
结构办法Thread(Runnabletarget,Stringname)
静态办法：
Thread.currentThread().getName()
Thread.sleep(1000)//java中单位是毫秒所以1000ms=1s，python中直接是秒
线程平安同步机制synchronized同步代码快，同步办法，可重入锁，可重入读写锁
参加synchronized同步办法，synchronized这个方式不如可重入锁平安，被synchronized修饰的要么取得锁，要么永远等候下去
publicclassCounter{
privateintvalue;
publicsynchronizedvoidinc(intm){
this.value+=m;
}
publicsynchronizedvoiddec(intm){
this.value-=m;
}
}
引入可重入锁即能够在同一个线程内屡次获取该锁
packagecom.ghc.test;
importjava.util.concurrent.locks.Lock;
importjava.util.concurrent.locks.ReentrantLock;
publicclassCounter{
privateLocklock=newReentrantLock();
privateintvalue;
publicvoidinc(intm){
if(lock.tryLock()){
try{
this.value+=m;
}finally{
lock.unlock();
}
}
}
publicvoiddec(intm){
if(lock.tryLock()){
try{
this.value-=m;
}finally{
lock.unlock();
}
}
}
publicintgetValue(){
lock.lock();
try{
returnthis.value;
}finally{
lock.unlock();
}
}
publicstaticvoidmain(String[]args)throwsInterruptedException{
System.out.println(Thread.currentThread().getName()+”start…”);
newThread(()->{
System.out.println(Thread.currentThread().getName()+”start…”);
try{
Thread.sleep(1000);
}catch(InterruptedExceptione){}
System.out.println(Thread.currentThread().getName()+”end…”);
},”downloadthread”).start();
Thread.sleep(500);
System.out.println(Thread.currentThread().getName()+”end…”);
}
}
引入可重入读写锁，由于能够同时读，不可同时写入或者说不可同时读写
引入可重入读写锁在同时写入的时分会加锁停止同步，而在同时读取的时分则不会进步并发性能
packagecom.ghc.test;
importjava.util.concurrent.locks.ReentrantReadWriteLock;
publicclassCounter{
privatefinalReentrantReadWriteLocklock=newReentrantReadWriteLock();
privatefinalReentrantReadWriteLock.ReadLockreadLock=lock.readLock();
privatefinalReentrantReadWriteLock.WriteLockwriteLock=lock.writeLock();
privateintvalue;
publicvoidinc(intm){
//写锁
writeLock.lock();
try{
this.value+=m;
}finally{
writeLock.unlock();
}
}
publicvoiddec(intm){
//读锁
readLock.lock();
try{
this.value-=m;
}finally{
readLock.unlock();
}
}
}