13：java并发编程总结

程序, 进程 和 线程
程序: 没有执行的指令序列和相关的数据的集合(如: qq.exe)
     如: 磁盘上的可执行命令.
进程: 正在执行的程序, 进程占用资源(CPU, Memoary, IO) 
线程: 是进程中并发运行的过程(共享进程资源)

同步: 步调一致的顺序执行, 如:上公交车, 一个一个上车
异步: 步调不一致的同时执行, 如: 大家一起上卡车

线程: 名词->类
  Thread 类中包含一个方法 run() 这个方法就是独立运行的
  过程
  Thread 类 中还包含方法start() 用来启动独立运行的run()

创建并启动一个线程:
  1 要覆盖Thread类的run() 方法, 提供独立运行的过程
  2 调用Thread实例的start() 方法启动 run() 过程.
 
线程的状态:
 [新建 new] --> [可运行(Runnable)] <--> [运行态(Running)]

软件执行时候至少包含main线程   

线程状态:
  1 new (新建)
  2 Runnable
  3 Running
  4 Block
  5 Dided

线程状态管理:
  Thread.yield() 当前线程让出处理器(离开Running),
    使当前线程进入Runnable等待
  Thread.sleep(times) 使当前线程从 Running 放弃处理器
    进入Block状态, 休眠times毫秒, 再返回到Runnable
    如果其他线程打断当前线程的Block(sleep), 就会发生
    InterruptedException.
 

线程离开运行状态的 3 种方法：
1、调用 Thread.sleep()：使当前线程睡眠至少多少毫秒（尽管它可能在指定的时
间之前被中断）。
2、调用 Thread.yield()：不能保障太多事情，尽管通常它会让当前运行线程回到
可运行性状态，使得有相同优先级的线程有机会执行。
3、调用 join()方法：保证当前线程停止执行，直到该线程所加入的线程完成为止。
然而，如果它加入的线程没有存活，则当前线程不需要停止。

除了以上三种方式外，还有下面几种特殊情况可能使线程离开运行状态：
1、线程的 run()方法完成。
2、在对象上调用 wait()方法（不是在线程上调用）。
3、线程不能在对象上获得锁定，它正试图运行该对象的方法代码。
4、线程调度程序可以决定将当前运行状态移动到可运行状态，以便让另一个线程获
得运行机会，而不需要任何理由。

 

后台线程(守护线程, 精灵线程)
  t4.setDaemon(true);
  Java进程的结束: 当前所有前台线程都结束时, Java进程结束
  后台线程, 不管是否结束, 都被停掉!
 
线程的优先级
  t3.setPriority(Thread.MAX_PRIORITY-1);
  默认有10 优先级, 优先级高的线程获得执行的机会多. 机会
  的多少不能通过代码干预.
  默认的优先级是 5

两种方式创建线程
  1 继承Thread类
    a 继承Thread类, 覆盖run()方法, 提供并发运程的过程
    b 创建这个类的实例
    c 使用start() 方法启动线程
  2 实现Runnable接口
    a 实现Runnable接口, 实现run()方法, 提供并发运程的过程
    b 创建这个类的实例, 用这个实例作为Thread构造器参数
      创建Thread类.
    c 使用start() 方法启动线程
   
    class Foo implements Runnable{
     public void run(){
      //....
     }
    }
    Thread t = new Thread(new Foo());
    t.start();
   
  3 使用内部类创建线程

可以使用 Thread.currentThread() 方法获得当前线程的引用

线程的同步
  1 多个线程并发读写同一个临界资源时候会发生线程安全问题
  2 可以使用 同步代码块解决 同步读写临界资源, 解决并发安全
  问题.
  3 a 同步代码块
    synchronized(同步监视器){
    }
    b 同步监视器 是一个任意对象实例. 是一个多个线程之间的互
    斥的锁机制. 多个线程要使用同一个"监视器" 实现同步互斥
    c 常见写法:
    synchronized(this){
    }
    d 如果方法的全部过程需要同步, 可以简单使用 synchronized
    修饰方法.
   

关于锁和同步，有一下几个要点：
1）、只能同步方法，而不能同步变量和类；
2）、每个对象只有一个锁；当提到同步时，应该清楚在什么上同步？也就是说，在
哪个对象上同步？
3）、不必同步类中所有的方法，类可以同时拥有同步和非同步方法。

4）、如果两个线程要执行一个类中的 synchronized 方法，并且两个线程使用相同
的实例来调用方法，那么一次只能有一个线程能够执行方法，另一个需要等待，直
到锁被释放。也就是说：如果一个线程在对象上获得一个锁，就没有任何其他线程
可以进入（该对象的）类中的任何一个同步方法。
5）、如果线程拥有同步和非同步方法，则非同步方法可以被多个线程自由访问而不
受锁的限制。
6）、线程睡眠时，它所持的任何锁都不会释放。 
7）、线程可以获得多个锁。比如，在一个对象的同步方法里面调用另外一个对象的
同步方法，则获取了两个对象的同步锁。

8）、同步损害并发性，应该尽可能缩小同步范围。同步不但可以同步整个方法，还
可以同步方法中一部分代码块。
9）、在使用同步代码块时候，应该指定在哪个对象上同步，也就是说要获取哪个对
象的锁。例如：
    public int fix(int y) {
        synchronized (this) {
            x = x - y;
        }
        return x;
    }

线程同步小结 
1、线程同步的目的是为了保护多个线程反问一个资源时对资源的破坏。
2、线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定
的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象
的其他同步方法。
3、对于静态同步方法，锁是针对这个类的，锁对象是该类的 Class 对象。静态和非
静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的
同步方法时，会获取这两个对象锁。 

 4、对于同步，要时刻清醒在哪个对象上同步，这是关键。
5、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正
确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争
资源。
6、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。

7、死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。真让你写个
死锁程序，不一定好使，呵呵。但是，一旦程序发生死锁，程序将死掉。

Java中同步的API
  1 StringBuffer 是同步的
      synchronized append();
    StringBuilder 不是同步的
      append();
  2 Vector 和 Hashtable 是同步的
    ArrayList 和 HashMap 不是同步的
   
  3 Collections.synchronizedList()
   ArrayList list = new ArrayList();
   List syncList = Collections.synchronizedList(list);
   
异步线程之间, 协作通信
  异步写文件操作

1 同步写文件: 从控制台读取一行,立即写道文件中

SCJP 所要求的线程交互知识点需要从 java.lang.Object java.lang.Object java.lang.Object 的类的三个方法来学
习：
 
 void notify() 
          唤醒在此对象监视器上等待的单个线程。 
 void notifyAll() 
          唤醒在此对象监视器上等待的所有线程。 
 void wait() 
          导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或
notifyAll() 方法。

 
关于等待/通知，要记住的关键点是：
必须从同步环境内调用 wait()、notify()、notifyAll()方法。线程不能调用对
象上等待或通知的方法，除非它拥有那个对象的锁。
wait()、notify()、notifyAll()都是 Object 的实例方法。与每个对象具有锁一
样，每个对象可以有一个线程列表，他 们等待来自该信号（通知）。线程通过

执行对象上的 wait()方法获得这个等待列表。从那时候起，它不再执行任何其
他指令，直到调用对象的 notify()方法为止。如果多个线程在同一个对象上等
待，则将只选择一个线程（不保证以何种顺序）继续执行。如果没有线程等待，
则不采取任何特殊操 作。

 
Timer 计时器