java多线程学习
参考：
http://blog.csdn.net/stellaah/article/details/6798244
http://bbs.csdn.net/topics/300116354
http://blog.csdn.net/ghsau/article/details/7421217
http://blog.csdn.net/sd0902/article/details/8395677
创建线程：
创建线程过程:
1.继承Thread
class 类名A extends Thread
{
public void run(){}
}
2.实例对象
Thread t=new 类名A();
3.启用线程
t.start();自动会去运行run().
2.Runable接口
实现Runnable接口创建线程
1.实现Runnable接口
类名A implements Runnable()
{
public void run(){}
}
2.启用线程
new Thread(类名A的对象).start();
区别：
使用Runnable接口创建多线程,适合多个相同的程序代码的线程去处理分享同一个资源的情况,把虚拟CPU(线程)同程序的代码数据有效分离,较好体现了面向对象的设计思想.
setDeamon(true)
设置守护线程，程序非守护线程全部退出时，守护线程自动退出。
join()，join(msecond) 合并线程（如何实现一个线程执行中让另一个线程先执行然后再继续执行自己）
t1.join(500) 打断当前线程执行t1线程,500msecond 如果t1线程死亡 则直接继续执行当前线程
package com.thread; public class JoinThread { public static void main(String[]args) { Thread o=new OneThread(); // o.start(); int index=0; while(true) { System.out.println("main->>"+index+" "+Thread.currentThread().getName()); try { Thread.sleep(500); } catch (InterruptedException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } if(index++==3) { try { o.start(); o.join();//把o对应的线程合并10000毫秒 } catch(Exception e) { e.printStackTrace();//输出导致异常更为详细的信息 } } } } } class OneThread extends Thread { public void run() { int i = 1; while(++i<10) { System.out.println("OneThread->>"+Thread.currentThread().getName()); try { Thread.sleep(500); } catch (InterruptedException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } } } } /* 运行的结果: 先是两个线程交替执行,main()方法的线程被执行30次后执行run方法的线程. run方法被执行10000毫秒后就变为刚开始时的样子---两个线程交替执行. */
Yield()
在多线程程序中,为了防止某线程独占CPU资源(这样其它的线程就得不到"响应"了).可以让当前执行的线程"休息"一下.但是这种thread.yield() 调用,并不保证下一个运行的线程就一定不是该线程.
public class Test extends Thread { public static void main(String[] args) { for (int i = 1; i <= 2; i++) { new Test().start(); } } public void run() { System.out.print("1"); yield(); System.out.print("2"); } } 输出结果： 1122 或者 1212
synchronized
synchronized代码块的用法-synchronized(Object){}
synchronized方法的用法需要与run()方法两个结合起来用
wait() notify
wait()休眠放弃资源控制锁
notify 唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。
notifyAll() 唤醒在此对象监视器上等待的所有线程
Timer TimerTask
自JDK5之后，可以用ScheduledThreadPoolExecutor来替代Timer。
ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(3);// 效果类似于Timer定时器
import java.util.*;
class ZhaDan extends TimerTask //炸弹
{
public void run()
{
System.out.println("Boang... ...炸了!");
}
}
class TimerTest
{
public static void main(String[]args)
{
Timer t=new Timer();//创建定时器对象
ZhaDan z=new ZhaDan();//创建炸弹对象
t.schedule(z,1000,2000);//隔1秒引爆炸弹.之后就是每2秒一炸
while(true)
{
try{Thread.sleep(1000);}catch(Exception e){}
System.out.println(new Date().getSeconds());//输出当前时间的秒
}
}
}
中断线程
while(flag)
用thread.interrupt()
或ThreadPoolExecutor.shutdown()
package cn.com.interrupt; import java.util.Scanner; public class Test extends Thread { private String name; public Test(String name) { this.name = name; } public void write() { System.out.print(name); } public static void main(String[]args) throws Exception{ Thread t1=new Test("myThread"); t1.start(); Scanner sc=new Scanner(System.in); String s; Thread.sleep(5000); t1.interrupt(); } public void run() { for(int i=0;;i++){ if(this.isInterrupted()){ System.out.println("exit*****************"); return; } write(); System.out.println(); } } }
线程同步问题首先要说明Java线程的两个特性:可见性，有序性
每个线程都有自己的工作内存(线程栈)，工作内存存储了主内存Count对象的一个副本，当线程操作Count对象时，首先从主内存复制Count对象到工作内存中，然后执行代码count.count()，改变了num值，最后用工作内存Count刷新主内存Count。当一个对象在多个内存中都存在副本时，如果一个内存修改了共享变量，其它线程也应该能够看到被修改后的值，此为可见性
多个线程执行时，CPU对线程的调度是随机的，我们不知道当前程序被执行到哪步就切换到了下一个线程，一个最经典的例子就是银行汇款问题，一个银行账户存款100，这时一个人从该账户取10元，同时另一个人向该账户汇10元，那么余额应该还是100。那么此时可能发生这种情况，A线程负责取款，B线程负责汇款，A从主内存读到100，B从主内存读到100，A执行减10操作，并将数据刷新到主内存，这时主内存数据100-10=90，而B内存执行加10操作，并将数据刷新到主内存，最后主内存数据100+10=110，显然这是一个严重的问题，我们要保证A线程和B线程有序执行，先取款后汇款或者先汇款后取款，此为有序性
synchronized volitile
synchronized:
1.修饰变量
sychronized（obj）｛
｝
2.修饰方法
void sychronized funA(){
}
每个锁对都有两个队列，一个是就绪队列，一个是阻塞队列，就绪队列存储了将要获得锁的线程，阻塞队列存储了被阻塞的线程，当一个线程被唤醒(notify)后，才会进入到就绪队列，等待CPU的调度，反之，当一个线程被wait后，就会进入阻塞队列，等待下一次被唤醒，这个涉及到线程间的通信，当第一个线程执行输出方法时，获得同步锁，执行输出方法，恰好此时第二个线程也要执行输出方法，但发现同步锁没有被释放，第二个线程就会进入就绪队列，等待锁被释放。一个线程执行互斥代码过程如下：
1. 获得同步锁；
2. 清空工作内存；
3. 从主内存拷贝对象副本到工作内存；
4. 执行代码(计算或者输出等)；
5. 刷新主内存数据；
6. 释放同步锁。
所以，synchronized既保证了多线程的并发有序性，又保证了多线程的内存可见性。
volitile:
修饰变量 不能和final一起修饰
static volatile int i = 0, j = 0;
volatile可以将共享变量的改变直接响应到主内存中，这样保证了主内存中的值一致性可以保证内存可见性，不能保证并发有序性
另 volatile 修饰函数 表示编译器不进行代码优化
线程池
创建一个可重用固定线程集合的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(3);
创建一个可根据需要创建新线程的线程池
ExecutorService threadPool = Executors.newCachedThreadPool();
创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程
ExecutorService threadPool = Executors.newSingleThreadExecutor();
创建一个可安排在给定延迟后运行命令或者定期地执行的线程池。
ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(3);
Future Callable
http://openhome.cc/Gossip/DesignPattern/FuturePattern.htm
Callable接口类似于Runnable，从名字就可以看出来了，但是Runnable不会返回结果，并且无法抛出返回结果的异常，而Callable功能更强大一些，被线程执行后，可以返回值，这个返回值可以被Future拿到，也就是说，Future可以拿到异步执行任务的返回值
Future模式在請求發生時，會先產生一個Future物件給發出請求的客戶，而同時間，真正的目標物件之生成，由一個 新的執行緒持續進行（即 Worker Thread），真正的目標物件生成之後，將之設定至Future之中，而當客戶端真正需要目標物件時， 目標物件也已經準備好，可以讓客戶提取使用。
Lock 锁
更广泛，继承类更多
private Lock lock = new ReentrantLock()
private ReadWriteLock rwl = new ReentrantReadWriteLock();
public interface Lock { void lock(); void lockInterruptibly() throws InterruptedException; boolean tryLock(); boolean tryLock(long time, TimeUnit unit) throws InterruptedException; void unlock(); Condition newCondition(); ｝
public class LockTest { public static void main(String[] args) { final Outputter1 output = new Outputter1(); new Thread() { public void run() { output.output("zhangsan"); }; }.start(); new Thread() { public void run() { output.output("lisi"); }; }.start(); } } class Outputter1 { private Lock lock = new ReentrantLock();// 锁对象 public void output(String name) { // TODO 线程输出方法 lock.lock();// 得到锁 try { for(int i = 0; i < name.length(); i++) { System.out.print(name.charAt(i)); } } finally { lock.unlock();// 释放锁 } } }
死锁实例：：
package com.test; public class SynchronizedSisuo { /** * @param args */ public static void main(String[] args) { SynchronizedSisuo ss = new SynchronizedSisuo(); ss.t1.start(); } Thread t1 = new Thread(new Runnable() { @Override public void run() { t1Run(); } }); Thread t2 = new Thread(new Runnable() { @Override public void run() { t2Run(); } }); Object obj = new Object(); public void t1Run() { synchronized (obj) { System.out.println("1111111>>>pre"); t2.start(); try { t2.join(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("1111111>>>pos"); } } public void t2Run() { synchronized (obj) { System.out.println("2222222>>>pre"); System.out.println("2222222>>>pos"); } } }
