Java多线程

线程的基本概念

线程是一个程序内部的顺序控制流
线程和进程的区别

• 每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销
• 线程可以看成是轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换的开销小
• 多进程：在操作系统中能同时运行多个任务（程序）（在一个时间点上其实ＣＰＵ只进行一个线程，但是速度非常快）
• 多线程：在同一应用程序中有多个顺序流同时执行

Java的线程是通过java.lang.Thread类来实现的
JVM启动时会有一个主方法（public static void main(String[] args){}）所定义的线程
可以通过创建线程Thread的实例来创建新的线程
每个线程都是通过某个特定的Thread对象所对应的run()方法来完成其操作的，方法run()称为线程体
通过调用Thread类的start()方法来启动一个线程
（不使用直接调用run()方法的原因是多线程的实现需要本地操作系统的支持）

线程的创建和启动

可以有两种方式创建新的线程
1、定义线程类实现Runnable接口

Thread myThread = new Thread(target) target为Runable接口类型
Runable中只有一个方法 ： public void run() 用以定义线程运行体
使用Runnable接口可以为多个线程提供共享的数据
在实现Runnable接口的类的run方法定义中可以使用Thread的静态方法public static Thread currentThread()获取当前线程的引用

2、可以定义一个Thread的子类并重写run方法

class MyThread extends Thread{ public void run(){...}}
然后生成该类的对象
MyThread myThread = new MyThread(…)
run()方法结束，线程结束
Thread 本身也实现了Runnable接口
例：

public class TestThread1 {
    public static void main(String[] args){
        //接口
        Runner1 r = new Runner1();
        Thread t1 = new Thread(r);
        t1.start();

        //继承
        Runner2 r2 = new Runner2();
        r2.start();

        for(int i = 0;i<10;i++){
            Systm.out.println("Main:"+i);
        }   
    }
}

class Runner1 implements Runnable{
    public void run(){
        for(int i = 0;i<10;i++){
            Systm.out.println("Runner1:"+i);
        }   
    }   
}

class Runner2 extends Thread{
    public void run(){
        for(int i = 0;i<10;i++){
            Systm.out.println("Runner2"+i);
        }   
    }
}

实现Runable接口的类比较灵活，能用接口尽量不要用继承

线程的状态转换

先看下图

线程控制的基本方法

方法	功能
isAlive()	判断线程是否还“活”着，即线程是否还未终止
getPriority()	获得线程的优先级数值
setPriority()	设置线程的优先级数值
Thread.sleep	将当期线程睡眠指定毫秒数
join()	调用某线程的方法，将当前线程与该线程“合并”，即等待该线程结束，再恢复当前线程的运行
yield()	让出CPU，当前线程进入就绪队列等待调度
wait()	当前线程进入对象的wait pool
notify()/notifyAll()	唤醒对象的wait pool中的一个/所有等待线程

sleep方法

• 可以调用Thread的静态方法
• public static void sleep(long millis) throws InterruptedException使得当前线程休眠（暂时停止执行millis毫秒）
• 由于是静态方法，sleep可以由类名直接调用Thread.sleep(...)

join方法

• 合并某个线程

yield方法

• 让出CPU，给其他线程执行的机会，但是自身也有执行的机会

import java.util.Date;

public class TestInterrupt {

    public static void main(String[] args) {
        MyThread myThread = new MyThread("myThread");
        //获得优先级
        //myThread.getPriority();
        //设置优先级
        //myThread.setPriority(Thread.NORM_PRIORITY + 3);
        myThread.start();

        try {
            //当此线程执行完毕才会继续执行主线程
            myThread.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        /*可让子线程结束，但不是最好的方法
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        myThread.interrupt();*/

        System.out.println("我是主线程");
    }
}

class MyThread extends Thread{
    MyThread(String s){
        super(s);
    }
    public void run() {
        while(true){
            System.out.println("====="+new Date()+"=====");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                return;
            }
        }
    }
}

线程的优先级别

• Java提供一个线程调度来监控程序中启动后进入就绪状态的所有线程，线程调度器按照线程的优先级决定应调度那个线程来执行
• 线程的优先级用数字表示，范围从1~10，一个线程的缺省优先级是5
• Thread.MIN_PRIORITY = 1
• Thread.MAX_PRIORITY = 10
• Thread.NORM_PRIORITY =5
• 使用下述方法获得或设置线程对象的优先级（见上例）
• int getPriority()
• void setPriority(int newPriority)

---

一个Thread对象可以起多个线程

    Runner r = new Runner();
    Thread t1 = new Thread(r);
    Thread t2 = new Thread(r);

---

线程同步

在Java语言中，引入了对象互斥锁的概念，保证共享数据操作的完整性。每个对象都对应于一个可称为“互斥锁”标记，这个标记保证在任一时刻，只能有一个线程访问该对象（保证一个时间段只有一个线程进入方法体，但是不保证其它的线程进入别的未上锁的方法）
关键字synchronized来于对象的互斥锁联系，当某个对synchronized修饰时表明该对象在任一时刻只能由一个线程访问
synchronized的使用方法

        synchronized(this){
        num++;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

synchronized还可以放在方法声明中，表示整个方法为同步方法
public synchronized void add(String name){...}

wait方法和sleep方法的区别
wait时别的线程可以访问锁定对象，调用wait方法的时候必须锁定该对象，wait是Object的方法
sleep时别的线程也不可以访问锁定对象，sleep是Thread的方法