多线程

创建一个线程有两种方式，一种及用一个类继承Thread类

class PrintThread extends Thread{
    public void run(){
        for(int i=1;i<=100;i++){
            System.out.println(this.getName()+"代码"+i);
            
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

另一种是通过实现Runnable接口

class Download implements Runnable{
    public void run(){
        for(int i=1;i<=10;i++){
            System.out.println("下载"+i);
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

他们都要重写Runnable接口中的run方法。

在主函数中调用时，
用第一种方法时，只需要new一个新的类的对象，并用Thread的引用指向他即可

Thread t=new PrintThread();

用第二种方法时，先new一个类的对象，然后作为参数传入Thread的带参的构造函数

Download d=new Download();
        Thread th=new Thread(d);

需要启动线程时，只需要调用对象.start()方法，就说明线程已经准备好，等待CPU运行

synchronized关键字可以对线程进行上锁，一段时间内只有一个线程可以执行，其他线程必须等待前一个线程执行完毕，才能继续执行

还有Thread的一个方法。
实例方法

getName() 返回线程名
getPriority() 返回线程优先级
interrupt() 中断线程
isAlive() 测试线程是否是激活状态
join() 等待该线程终止
setDaemon(boolean on) 标记为守护线程

类方法

sleep(long millis) 休眠多少毫秒
currentThread() 返回正在执行线程的对象的引用
yield() 暂停当前线程

wait()
在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
notify()
唤醒在此对象监视器上等待的单个线程。
比如下面程序

public class LearnThreadCommunication {
public static void main(String[] args) {
    Box b=new Box();
    Thread p=new Producer(b);
    Thread c=new Consumer(b);
    p.start();
    c.start();
}
}
class Box {
    public int boxValue=0;  
}
class Producer extends Thread{
    private Box box;
    public Producer(Box box){
        this.box=box;
    }
    public void run(){
        for(int i=1;i<6;i++){
            synchronized (box) {
                while(box.boxValue!=0){
                    try {
                        System.out.println("Producer:进入等待");
                        box.wait();
                        
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                box.boxValue=i;
                System.out.println("Producer:Box中放入"+i+"通知其他等待者");
                box.notify();
            }
        }
    }
}
class Consumer extends Thread{
    private Box box;
    public Consumer(Box box){
        this.box=box;
    }
    public void run(){
        for(int i=1;i<6;i++){
            synchronized (box) {
                while(box.boxValue==0){
                    try {
                        System.out.println("Consumer:进入等待");
                        box.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                box.boxValue=0;
                System.out.println("Consumer:Box中取出"+i+"通知其他等待者");
                box.notify();
            }
        }
    }
}

线程的死锁
两个线程，正在使用一个对象，同时他们都在等待使用另外一个线程的对象，形成死锁
代码

public class LearnThreadDead {
    public static void main(String[] args) {
        Object lock1 = new Object();
        Object lock2 = new Object();
        ThreadA ta = new ThreadA(lock1, lock2);
        ThreadB tb = new ThreadB(lock1, lock2);
        ta.start();
        tb.start();
    }
}

class ThreadA extends Thread {
    Object lock1;
    Object lock2;

    public ThreadA(Object lock1, Object lock2) {
        this.lock1 = lock1;
        this.lock2 = lock2;
    }

    public void run() {
        synchronized (lock1) {
            System.out.println("线程A拿到了lock1");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            synchronized (lock2) {
                System.out.println("线程A拿到类lock1和lock2");
            }
        }
    }
}

class ThreadB extends Thread {
    Object lock1;
    Object lock2;

    public ThreadB(Object lock1, Object lock2) {
        this.lock1 = lock1;
        this.lock2 = lock2;
    }

    public void run() {
        synchronized (lock2) {
            System.out.println("线程B拿到了lock2");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            synchronized (lock1) {
                System.out.println("线程B拿到类lock1和lock2");
            }
        }

    }
}

http://blog.jobbole.com/76308/ 多线程学习