[Java] 深入理解Java多线程与并发编程

int a = 10; //语句1
int r = 2; //语句2
a = a + 3; //语句3
r = a*a;  //语句4

• 1.volatile轻量级，只能修饰变量。synchronized重量级，还可修饰方法。
  
• 2.volatile只能保证数据的可见性，不能用来同步，因为多个线程并发访问volatile修饰的变量不会阻塞。
  

package chauncy.concurrentprogramming;
 
class threadvolatile extends thread {
  public volatile boolean flag = true;
 
  @override
  public void run() {
    system.out.println("子线程开始执行...");
    while (flag) {
 
    }
    system.out.println("子线程结束执行...");
  }
 
  public void isrun(boolean flag) {
    this.flag = flag;
  }
}
 
/**
 * @classdesc: 功能描述(volatile关键字的使用)
 * @author: chauncywang
 * @createtime: 2019年3月12日 上午10:17:14
 * @version: 1.0
 */
public class volatile {
  public static void main(string[] args) throws interruptedexception {
    threadvolatile threadvolatile1 = new threadvolatile();
    threadvolatile1.start();
    thread.sleep(300);
    /**
     * 如果不对变量加volatile关键字，则子线程不会停止运行 原因：线程之间是不可见的，读取的是副本，没有及时读取到主内存结果。
     * 解决办法：使用volatile关键字解决线程之间的可见性，强制线程每次读取该值的时候都去“主内存”中取值。
     */
    threadvolatile1.isrun(false);
    system.out.println("flag:" + threadvolatile1.flag);
  }
}

package chauncy.concurrentprogramming;
 
import java.util.concurrent.atomic.atomicinteger;
 
class volatilenoatomicthread extends thread {
  // private static volatile int count = 0;
  private static atomicinteger atomicinteger = new atomicinteger(0);
 
  @override
  public void run() {
    for (int i = 0; i < 1000; i++) {
      // count++;
      atomicinteger.incrementandget();// count++
    }
    system.out.println(getname() + "-----" + atomicinteger);
  }
}
 
/**
 * @classdesc: 功能描述(volatile修饰不具有原子性(不具有同步性)，不能解决线程安全问题)
 * @author: chauncywang
 * @createtime: 2019年3月12日 上午10:39:30
 * @version: 1.0
 */
public class volatilenoatomic {
  public static void main(string[] args) {
    // 初始化10个线程
    volatilenoatomicthread[] volatilenoatomicthread = new volatilenoatomicthread[10];
    for (int i = 0; i < volatilenoatomicthread.length; i++) {
      // 创建每一个线程
      volatilenoatomicthread[i] = new volatilenoatomicthread();
    }
    for (int i = 0; i < volatilenoatomicthread.length; i++) {
      // 启动每一个线程
      volatilenoatomicthread[i].start();
    }
  }
}

• void set(object value)设置当前线程的线程局部变量的值；
  
• public object get()该方法返回当前线程所对应的线程局部变量；
  
• public void remove()将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是jdk5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存的回收速度；
  
• protected object initialvalue()返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(object)时才执行，并且仅执行1次。threadlocal中的缺省实现直接返回一个null。
  

package chauncy.concurrentprogramming;
 
class res {
  // private int count=0;
  /*
   * 设置本地局部变量，和其他线程局部变量隔离开，互不影响
   */
  private threadlocal<integer> count = new threadlocal<integer>() {
    protected integer initialvalue() {
      // 设置当前线程局部变量的初始化值
      return 0;
    };
  };
 
  /**
   * 
   * @methoddesc: 功能描述(生成订单号)
   * @author: chauncywang
   * @param: @return
   * @createtime: 2019年3月12日 下午2:23:57
   * @returntype: int
   */
  public integer getnum() {
    int count = this.count.get() + 1;
    this.count.set(count);
    return count;
  }
}
 
class threadlocaldemo extends thread {
  private res res;
 
  public threadlocaldemo(res res) {
    this.res = res;
  }
 
  @override
  public void run() {
    for (int i = 0; i < 3; i++) {
      try {
        thread.sleep(30);
      } catch (exception e) {
      }
      system.out.println(getname() + "----i:" + i + ",number:" + res.getnum());
    }
  }
}
 
/**
 * @classdesc: 功能描述(本地线程的使用：创建三个线程，每个线程生成自己独立的序列号)
 * @author: chauncywang
 * @createtime: 2019年3月12日 下午2:21:03
 * @version: 1.0
 */
public class threadlocaltest {
  public static void main(string[] args) {
    res res = new res();
    threadlocaldemo t1 = new threadlocaldemo(res);
    threadlocaldemo t2 = new threadlocaldemo(res);
    threadlocaldemo t3 = new threadlocaldemo(res);
    t1.start();
    t2.start();
    t3.start();
  }
}

• 1.线程池改进了一个应用程序的相应时间。由于线程池中的线程已经准备好且等待被分配任务，应用程序可以直接拿来使用而不用新建一个线程。
  
• 2.线程池节省了clr为每个短生命周期任务创建一个完整的线程开销并可以在任务完成后回收资源。
  
• 3.线程池根据当前在系统中运行的进程来优化线程时间片。
  
• 4.线程池允许我们开启多个任务而不用为每个线程设置属性。
  
• 5.线程池允许我们为正在执行任务的程序参数传递一个包含状态信息的对象引用。
  
• 6.线程池可以用来解决处理一个特定请求最大线程数量限制问题。
  

• 1.newcachedthreadpool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
  
• 2.newfixedthreadpool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
  
• 3.newscheduledthreadpool 创建一个定长线程池，支持定时及周期性任务执行
  
• 4.newsinglethreadexecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(fifo,lifo,优先级)执行。(一般不会使用)
  

package chauncy.concurrentprogramming.executors;
 
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
 
public class newcachedthreadpool {
  public static void main(string[] args) {
    // 创建可缓存线程池
    executorservice newcachedthreadpool = executors.newcachedthreadpool();
    // 执行execute方法表示创建了一个线程，类似于start
    for (int i = 0; i < 30; i++) {
      int index = i;
      // index++;
      newcachedthreadpool.execute(new runnable() {
 
        @override
        public void run() {
          try {
            thread.sleep(300);
          } catch (interruptedexception e) {
          }
          // 内部类中使用的i必须是final,但是换成index后就不报错，因为jdk1.8进行了优化，能识别index是否被改变，如果把int
          // index=i;下边的index++放开就会报错。
          system.out.println(thread.currentthread().getname() + "----" + index);
        }
      });
    }
    // 关闭线程池
    newcachedthreadpool.shutdown();
  }
}

package chauncy.concurrentprogramming.executors;
 
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
 
public class newfixedthreadpool {
  public static void main(string[] args) {
    // newfixedthreadpool 每次最多只能执行三个，其他线程等待执行。
    executorservice newfixedthreadpool = executors.newfixedthreadpool(3);
    for (int i = 0; i < 10; i++) {
      int index = i;
      newfixedthreadpool.execute(new runnable() {
        public void run() {
          try {
            thread.sleep(1000);
          } catch (interruptedexception e) {
          }
          system.out.println(thread.currentthread().getname() + "----i:" + index);
        }
      });
    }
  }
}

package chauncy.concurrentprogramming.executors;
 
import java.util.concurrent.executors;
import java.util.concurrent.scheduledexecutorservice;
import java.util.concurrent.timeunit;
 
public class newscheduledthreadpool {
  public static void main(string[] args) {
    // 入参为线程池大小，
    scheduledexecutorservice newscheduledthreadpool = executors.newscheduledthreadpool(5);
    // schedule执行定时任务线程池,第一个参数需要创建runnable接口对象，第二、三个参数表示多少个单位时间执行run方法。
    newscheduledthreadpool.schedule(new runnable() {
      public void run() {
        system.out.println("我是三秒钟之后执行。。。。");
      }
    }, 3, timeunit.seconds);
  }
}

package chauncy.concurrentprogramming.executors;
 
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
 
public class newsinglethreadexecutor {
  public static void main(string[] args) {
    executorservice newsinglethreadexecutor = executors.newsinglethreadexecutor();
    for (int i = 0; i < 10; i++) {
      int index = i;
      newsinglethreadexecutor.execute(new runnable() {
        public void run() {
          system.out.println(thread.currentthread().getname() + "----i:" + index);
        }
      });
    }
  }
}