java线程详解二

线程的优先级

线程调度：按照特定的机制为线程分配CPU的时间片段的行为，java程序再运行的时候，由java虚拟机负责线程的调度

线程调度的实现方式：1、分时调度，2、抢占式调度

分时调度：指让所有线程轮流获取CPU的使用权，并为每个线程平均分配CPU的时间片段

抢占式调度：指选择优先级较高的线程执行，如果所有的线程优先级相同，则会随机选择一个线程执行，java虚拟机正是采用这个调度模式。

线程优先级范例一：

public class ThreadTest5 {

    public static void main(String[] args) {

        Thread th = new Thread(new Runnable() {
            @Override
            public void run() {

                for (int i = 0; i <100 ; i++) {

                    System.out.println(Thread.currentThread().getName());
                }


            }
        });
        th.setPriority(1);//设置该线程的优先级
        th.start();//开启这个线程，并执行run方法
        System.out.println(th.getPriority());//获取该线程的优先级


        Thread th2 = new Thread(new Runnable() {
            @Override
            public void run() {

                for (int i = 0; i <100 ; i++) {

                    System.out.println(Thread.currentThread().getName());
                }


            }
        });
        th2.setPriority(10);//设置该线程的优先级
        th2.start();//开启这个线程，并执行run方法
        System.out.println(th2.getPriority());//获取该线程的优先级




    }
}

注意：自定义的线程和main方法主线程的优先级默认都是5，线程的优先级用数据表示，范围1~10

线程同步

什么是线程安全：多线程应用程序同时访问共享对象时，由于线程之间相互抢占CPU的控制权，会造成一个线程夹在另一个线程的执行过程中运行，会造成错误的执行的过程

synchronized关键字：确保共享对象只能被一个线程访问，这种机制称为线程同步或者线程互斥，java中的线程同步是基于对象锁的概念。

synchronized关键字使用范例

public class ThreadTest6 {

    public static void main(String[] args) {

        maipiao maipiao = new maipiao();

        Thread t1 = new Thread(maipiao,"学生");
        Thread t2 = new Thread(maipiao,"白领");
        Thread t3 = new Thread(maipiao,"工人");

        t1.start();
        t2.start();
        t3.start();

    }




}

/**
 *定义一个线程类
 */
class maipiao implements Runnable{

    private Integer ticket = 100;//定义100张票
    private Boolean state = true;
    @Override
    public void run() {

        while (state){
            function();
        }

    }

    /**
     * 买票的实现方法
     *synchronized关键字：加在方法上该方法就是一个同步方法，在某一个时间片段只能由一个线程方法该方法
     */

    public /*synchronized*/ void function(){

        //也可以用同步代码块的方式保持同步
        synchronized (this){
            if(ticket<=0){
                state=false;
                return;
            }

            try {
                Thread.sleep(1000);//让线程睡眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if(state){
                System.out.println(Thread.currentThread().getName()+"-抢到了第"+ticket--+"张票");
            }
        }


    }
}

同步方法和同步代码块的作用是一样的，只是控制的范围不一样，范围越大，性能越差，所以一般使用同步代码块来保持线程同步

线程之间的通信

列举3个重要的方法：均是java.lang.Object中的方法，只能在同步方法或者同步代码块中使用，否则会抛出异常

wait()方法：中断方法的执行，使当前线程等待，暂时让出CPU的使用权，并允许其他线程使用该同步方法。

notify()方法：唤醒单个使用同步方法等待的线程

notifyall()方法：唤醒所有使用同步方法等待的线程

生产者消费者问题

 

/*    范例名称：生产者--消费者问题
 *     源文件名称：ProducerConsumer.java
 *    要  点：
 *        1. 共享数据的不一致性/临界资源的保护
 *        2. Java对象锁的概念
 *        3. synchronized关键字/wait()及notify()方法
 */

public class ProducerConsumer {
    public static void main(String args[]){
        SyncStack stack = new SyncStack();
        Runnable p=new Producer(stack);
        Runnable c = new Consumer(stack);
        Thread p1 = new Thread(p);
        Thread c1 = new Thread(c);

        p1.start();
        c1.start();
    }
}


class SyncStack{  //支持多线程同步操作的堆栈的实现
    private int index = 0;
    private char[] data = new char[6];

    public synchronized void push(char c){
        if(index == data.length){
            try{
                this.wait();
            }catch(InterruptedException e){}
        }
        this.notify();
        data[index] = c;
        index++;
    }

    public synchronized char pop(){
        if(index ==0){
            try{
                this.wait();
            }catch(InterruptedException e){}
        }
        this.notify();
        index--;
        return data[index];
    }
}


class  Producer implements Runnable{
    SyncStack stack;
    public Producer(SyncStack s){
        stack = s;
    }
    public void run(){
        for(int i=0; i<20; i++){
            char c =(char)(Math.random()*26+'A');
            stack.push(c);
            System.out.println("produced："+c);
            try{
                Thread.sleep((int)(Math.random()*1000));
            }catch(InterruptedException e){
            }
        }
    }
}


class Consumer implements Runnable{
    SyncStack stack;
    public Consumer(SyncStack s){
        stack = s;
    }
    public void run(){
        for(int i=0;i<20;i++){
            char c = stack.pop();
            System.out.println("消费："+c);
            try{
                Thread.sleep((int)(Math.random()*1000));
            }catch(InterruptedException e){
            }
        }
    }
}