java多线程知识点收集-总

1.线程与进程的关系

进程（Process）：当一个程序进入内存开始运行时，就产生一个进程。进程是一个独立单元，它的资源由系统分配和调度。

线程（Thread）：线程是进程的执行单元，线程在进程中是独立的、并发的执行流。当进程被初始化后，主线程（main）就被创建。

1）线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程。

2）线程拥有自己的堆栈、程序计数器以及局部变脸，但不拥有系统资源，它与父进程的其他线程共享共享父进程的全部资源。

3）线程的调度和管理由进程本身负责完成。

 

2.创建线程的方式

http://www.cnblogs.com/moonpool/p/5472549.html

有三种创建方法

1）继承Thread类--不能资源共享，当实现方便

Thread类是一个抽象类

2）实现Runnable接口--可以资源共享，在新建Thread对象时，需要Runnable接口实现类的对象作为target

Runnable是一个接口类

3）使用Callable和Future创建线程--有返回值的线程

 Callable和Future都是接口类，FutureTask是Future的实现类

3.线程的生命周期（图片来自java疯狂讲义）

 

4.线程控制方法

http://www.cnblogs.com/moonpool/p/5494935.html

1）join--Thread中的方法，由使用线程的程序调用

--如果对象A在自己方法内使用对象B.join , 那么A的线程就会被阻塞，等到B线程死亡，A线程才能继续。

2）后台线程--Thread中的方法setDeamon(true)

--守护进程，当前台线程全部死亡后，后台线程也随之死亡

3）sleep--Thread类的静态方法

--在设置的时间内处于阻塞状态，时间一到，就变成就绪状态，等待被调用

4）yield与线程优先级--Thread类的静态方法

--使用了该方法后，当前线程就会变成就绪状态，操作系统就会在处于就绪状态的线程中，挑选优先级最高的线程，给它分配资源并允许。正常的线程都是普通优先级，优先级还有高级和低级，有相应的方法去设置。

 

5.线程同步方法

http://www.cnblogs.com/moonpool/p/5480593.html

1）同步代码块--在重写run（）方法时使用synchronized修饰符修饰代码块

2）同步方法--在定义类时使用synchronized修饰符修饰修改方法

3）同步锁lock--lock和ReadWriteLock两个接口，对应的实现类是ReentrantLock以及ReentrantReadWriteLock

 

6.线程通讯方法

 http://www.cnblogs.com/moonpool/p/5496887.html

1)如果采用的是同步代码块和同步方法的方式来实现线程的同步，就需要使用传统的线程通讯方式

在被线程调用方法(该方法被synchronized修饰)内添加wait ()、notify()以及notifyAll(),来阻塞调用线程或者通知其他线程运行。

wait ()、notify()以及notifyAll()这三个方法是由Object类提供

 

http://www.cnblogs.com/moonpool/p/5500845.html

2)如果采用的是同步锁方式来实现线程同步，就需要使用Condition控制线程通讯

和第一种类似，这里需要使用Condition对象在被线程调用方法(该方法不需要被synchronized修饰)内添加Lock.lock()、Condition.await ()、Condition.signal()、Condition.signalAll()以及Lock.unlock(),来实现线程通信

这里首先需要由lock对象的newCondition（）方法返回一个Condition对象，await ()、signal()、signalAll()是Condition对象提供的方法

class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length)
         notFull.await();
       items[putptr] = x;
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }

   public Object take() throws InterruptedException {
     lock.lock();
     try {
       while (count == 0)
         notEmpty.await();
       Object x = items[takeptr];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally {
       lock.unlock();
     }
   }
 }

 

 http://www.cnblogs.com/moonpool/p/5503287.html

3）阻塞队列（BlockingQueue）

BlockingQueue是Queue的子接口，但主要用于线程同步

	抛出异常	不同的返回值	阻塞线程	指定超时时间
队尾插入元素	add(e)	offer(e)	put(e)	offer(e,time,unit)
对头删除元素	remove()	poll()	take()	poll(time,unit)
获取、不删除元素	element()	peek()	无	无

 

 

 

 

----------------------------------------------------------------------------------------------

7.线程组

可以将线程分类管理，并设置优先级等

 ThreadGroup类

由Thread类提供的构造方法来指定新建的线程属于哪个线程组。

8.线程池

 存在的目的就是为了节省系统资源，将新建好的线程放入线程池，由线程池给线程分配资源并运行，当该线程销往后，给该线程分配的资源将会被回收回线程池。

 由Executor工厂类提供的静态工厂方法来创建ExecutorService对象

9.线程相关类

 ThreadLocal类     该类的成员变量在被线程调用时，将会产生一个副本，让线程可以随意维护自己拥有的变量副本，从而保证线程之前不会产生资源冲突，这和资源共享的同步方法由本质区别，使用场景也不一样。

线程安全的集合类   正常的集合类都是线程不安全的，这里线程安全的集合类就是可以被线程调用时产生一个副本，最终可以保证原集合的数据完整性。

思考：线程相关类的使用场景。