关于Java线程

一、线程具有优先级(priority)

线程的优先级分为十个等级，分别从1到10，优先级的高低决定了线程被CPU执行的先后顺序。（但不是绝对的，只是优先级越高，抢占CPU的几率就越大）

Thread类有三个关于线程优先级的静态变量：MAX_PRIORITY表示最大优先级，为10；MIN_PRIORITY表示最先优先级，为1；NORM_PRIORITY表示普通优先级，为5.

二、线程的调度

线程的调度有两种模型：分时模型和抢占模型

分时模型：线程在指定的时间里执行（在CPU上）

抢占模型：线程一旦获得执行权，就一直执行下去。（Java语言支持的是抢占模型）

（重点）三、Java的Thread线程类和Runnable接口

创造线程有两种方法，一种是继承Thread类，一种是实现Runnable接口

Thread类是线程类，利用Thread的子类创造线程

Runnable是接口，只有一个run()方法。相当于重写了Thread类的run()方法。但实现Runnable接口的类必须作为另一个Thread类对象的参数，以此来创造线程。

继承Thread类创造线程 1

 1 class MyThread extends Thread{　　//继承Thread类
    private String who;
    public MyThread(String str) {
        who=str;        //初始化who
    }
    //覆盖Thread的run方法，线程的开始也是从run开始的
    public void run() {
        System.out.println(who+"最先运行");
    }
}
public class UseThread {
    public static void main(String[] args) {
        MyThread you=new MyThread("你");
        MyThread she=new MyThread("她");
        she.setPriority(1);        //设置she的优先级
        you.start();    //你  线程开始
        she.start();    //她  线程开始
        //注意是start()
        System.out.println("you的优先级为"+you.getPriority());
        System.out.println("she的优先级为"+she.getPriority());
        System.out.println("main结束");
    }
}

实现Runnable接口创造线程

class MyRun implements Runnable{
    private String who;
    public MyRun(String str) {
        who=str;
    }
    @Override
    public void run() {
        for(int i=0;i<5;i++) {
            try {
                //因为是实现接口所以需要加前缀Thread
                Thread.sleep((int)(1000*Math.random()));
            } catch (Exception e) {
                System.out.println(e.toString());
            }
            System.out.println(who+"正在运行！！");
        }
    }
}
public class UseRunnable  {
    public static void main(String[] args) {
        /*
        MyRun you=new MyRun("你");
        MyRun she=new MyRun("她");
        //将实现接口的对象床底给Thread并生成Thread对象
        Thread t1=new Thread(you);
        Thread t2=new Thread(she);
        t1.start();
        t2.start();
        System.out.println("main运行结束");
        */
        //让you和she逐个运行
        MyRun you=new MyRun("你");
        MyRun she=new MyRun("她");
        //将实现接口的对象床底给Thread并生成Thread对象
        Thread t1=new Thread(you);
        Thread t2=new Thread(she);
        t1.start();
        try {
            t1.join();　　　　//使用join（）时，需让此时的线程先执行完，下一个线程才能执行
        } catch (InterruptedException e) {
            System.out.println(e.toString());
        }
        t2.start();
        try {
            t2.join();
        } catch (InterruptedException e) {
            System.out.println(e.toString());
        }
        System.out.println("main运行结束");
    }
}

（main方法也是一个线程）

四、关于线程的数据共享

如果线程的操作是共享某个数据，一般都是用实现Runnable接口的类，把数据放在Runnable接口的类中，然后再创造线程。

比如三个线程在售票

class ThreadShare implements Runnable{
    private int tickets=10;
    @Override
    public void run() {
        while(true) {
            if(tickets>0) {
                System.out.println(Thread.currentThread().getName()+"售机票第"+tickets--+"号");
            }
            else
                System.exit(0);
        }
    }
    
}
public class ThreadShareMain {
    public static void main(String[] args) {
        ThreadShare t=new ThreadShare();
        //用此对象t作为参数创建三个线程
        Thread t1=new Thread(t,"第1售票窗口");
        Thread t2=new Thread(t,"第2售票窗口");
        Thread t3=new Thread(t,"第3售票窗口");
        t1.start();
        t2.start();
        t3.start();
    }
}

五、关于同步线程

线程在一个完整操作的所有动作的执行过程中，都占有相关资源而不被打断。

临界资源：在一个时刻只能被一个线程访问的资源

临界代码：访问临界资源的那段代码

六、“互斥锁”机制

Java每个对象都有一个“互斥锁”与之连接。一个对象只有一个互斥锁。一个线程只有获得互斥锁后，对其进行操作，而另一个线程只能处于等待状态。所以利用对一个对象互斥锁的争夺，可以实现不同线程的互斥效果。

七、synchronized关键字标识同步的资源

格式一：同步语句

Synchronized(对象){

　　临界代码段

}

格式二：同步方法

public synchronized 返回类型 方法名(){

　　方法体

}

synchronized的功能是先判断对象或方法的互斥锁是否存在，若存在就获得互斥锁，然后执行紧随其后的临界代码或方法体；如果对象的互斥锁不存在（已被其他线程拿走），就进入等待状态，直到获得互斥锁。

synchronized很好的解决像银行业务取款并发的情况

//模拟银行账户类
class Mbank{
    private static int sum=2000;
    //修饰线程同步的方法
    public synchronized static void take(int k) {
        int temp=sum;
        temp-=k;
        try {
            Thread.sleep((int)(1000*Math.random()));
        } catch (InterruptedException e) {
            e.toString();
        }
        sum=temp;
        System.out.println(Thread.currentThread().getName()+"sum="+sum);
    }
}
//模拟用户取款
class Customer extends Thread{
    public void run() {
        for(int i=0;i<4;i++) {
            Mbank.take(100);　　//　用户每次取出100，取四次
        }
    }
}

//调用线程的主类
public class SynchronizedThread {
    public static void main(String[] args) {
        Customer c1=new Customer();
        Customer c2=new Customer();
        c1.start();
        c2.start();
    }
}

八、线程之间的通信

一个线程的执行，需要另一个线程配合，就称作线程的通信

例如：售票操作只有当有存票才能进行售票，不然只有当存票操作后才能进行售票。

线程的通信需要用到java.lang.Object类的三个方法：

wait():线程A执行了对象x的同步代码(synchronized)里的wait()方法，该线程暂停进行，然后进入对象x的等待队列，并释放对象x的互斥锁。直到其他线程在对象x上调用notify()或notifyAll()方法，才能够重新获得对象x的互斥锁。

notify():唤醒正在等待该对象互斥锁的第一个线程

notifyAll():唤醒正在等待该对象互斥锁的所有线程，具有最高优先级的线程首先被唤醒

（wait方法必须写在try-catch里面）

写一个简单的存票售票程序：

//模拟存票与售票
class Tickets{
    protected int size;//总票数
    int number=0;     //票号
    boolean available=false;    //表示当前是否有票可售
    public Tickets(int n) {
        this.size=n;
    }
    /*
     * 同步方法，实现存票
     */
    public synchronized void put() {
        if(available) {    //如果还有剩余票就等待
            try {
                wait();
            } catch (Exception e) { }
        }
        System.out.println("存入第【"+(++number)+"】号票");
        available=true;
        notify();    //存票后唤醒售票线程开始售票
    }
    /*
     * 同步方法，实现售票
     */
    public synchronized void sell() {
        if(!available) {    //如果没有票，则售票线程等待
            try {
                wait();
            } catch (Exception e) {    }
        }
        System.out.println("售出第【"+(number)+"】号票");
        available=false;
        notify();        //售票后唤醒存票线程开始存票
        if(number==size)number=size+1;    //在售完最后一张票后，设置一个结束标志
        //number>size表示售票结束
    }
}
//存票线程类
class Producer extends Thread{
    Tickets t=null;
    public Producer(Tickets t) {
        this.t=t;
    }
    public void run() {
        while(t.number<t.size) {
            t.put();
        }
    }
}
class Consumer extends Thread{
    Tickets t=null;
    public Consumer(Tickets t) {
        this.t=t;
    }
    public void run() {
        while(t.number<=t.size) {
            t.sell();
        }
    }
}
public class ThreadNotify {
    public static void main(String[] args) {
        Tickets t=new Tickets(10);
        new Producer(t).start();    //存票线程开始
        new Consumer(t).start();    //售票线程开始
    }
}