java高并发程序设计学习笔记（三）

volatile与JMM内存模型

java的JMM内存模型围绕着原子性，有序性，可见性展开，关键字volatile的作用就十分有用了。volatile用于修饰线程界限区内数据的内存变量。保证了该变量不会在并发情况下出现数据不一致的情况。
被volatile修饰的变量告诉了java虚拟机这是一个很容易被线程修改的变量，因此java虚拟机会时时刻刻注意这个变量。一旦发生变化，便会通知其他线程这个变量进行了修改，而避免发生数据不一致的情况。

     public volatile static int j = 0;
     public static void main(String[] args) {
     Thread t1 = new Thread(){
           public void run(){
                for(int i = 0;i<100000;i++) {
                    j++;
                }
            }
      }; 
      Thread t2 = new Thread(){
            public void run(){
                for(int i = 0;i<100000;i++) {
                    j++;
                }
            }
      }; 
      t1.start();
      t2.start();
      try {
           t1.join();
           t2.join();
      }catch (Exception e) {
           e.printStackTrace();
      }
      System.out.println(j);
 }

但是这个情况就是个例外，尽管给变量j加以volatile修饰，但结果却不是意料中的200000，实际测试却只有100000多一些。

线程组

如果几个线程的功能很单一，就可以放进线程组里方便管理。如下。

public class thread implements Runnable{
    public static void main(String[] args) {
        ThreadGroup tg = new ThreadGroup("read");
        Thread t1 = new Thread(tg,new thread(),"t1");
        Thread t2 = new Thread(tg,new thread(),"t2");
        t1.start();
        t2.start();
        System.out.println(tg.activeCount());
        tg.list();
    }
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

tg.activeCount()用来获得当前活动线程的总数，由于线程是动态的，所以提供的值仅供参考。

守护线程

守护线程，主线程，非守护线程。守护线程默默在系统背后完成任务，例如gc，jit。非守护线程则是用户创建线程，主线程是main。

public class thread {
    public static class DaemonT extends Thread{
        public void run() {
            while(true) {
                System.out.println("每秒执行");
                try {
                   Thread.sleep(1000);
                }catch (Exception e) {}
            }
         }
    }
    public static void main(String[] args) {
        Thread t = new DaemonT();
        t.setDaemon(true);
        t.start();
        try {
            Thread.sleep(3000);
       }catch (Exception e) {}
    }
}

在main方法里把t1线程设置成了守护线程，并且这个线程每秒执行输出一句话。主线程等待三秒后结束。此时若主线程结束，而t1线程又是守护线程，所以main方法结束后，系统中没有其他正在执行的用户线程，所以守护线程t1也结束运行，并不会死循环。

线程优先级

java中的线程具有优先级，优先级高的线程更容易被系统分配到cpu时间片。只是概率变高了，因此几个高优先级的线程和一个低优先级的线程一块运行，低优先级的线程一直没有被系统分配到时间片就会发生饥饿。在java中，线程优先级有1-10的等级，等级越高优先级越高。

public static class maxThread extends Thread{
   public void run() {
       int a = 0;
       synchronized (thread.class) {
          while(true) {
              a++;
              if(a>100000) {
                  System.out.println("max");
                  break;
              }
         }
      }
   }
}
public static class minThread extends Thread{
   public void run() {
       int a = 0;
       synchronized (thread.class) {
          while(true) {
             a++;
             if(a>100000) {
                 System.out.println("min");
                 break;
             }
          }
      }
  }
}
public static void main(String[] args) {
    Thread max = new maxThread();
    Thread min = new minThread();
    max.setPriority(10);
    min.setPriority(1);
    max.start();
    min.start();
}