Java多线程的调度与控制

Java多线程的调度与控制

主要内容：

1、线程的互斥
2、线程中方法演示

互斥锁的演示

public class MyStack {
    private char[] data = new char[6];
    private int idx=0;
    //无论是锁方法还是同步块地锁，只要对象锁是同一个，都可以锁成---效果是一样的
    public void push( char c){
        System.out.println(".....");
        synchronized (this) {//拿锁--对象锁是this
            data[idx] = c;
            System.out.println("push:" + c);
            idx++;
            this.notify();
        }//还锁
    }
    public synchronized char pop(){//拿锁 --对象锁是this
        if(idx<=0){
            try {
                //CPU资源，两者都会释放的!
                //Thread.sleep(10);//sleep不会释放对象锁
                this.wait();//wait会释放对象锁
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        idx--;
        System.out.println("pop:"+ data[idx]);
        return data[idx];
    }//还锁
}

线程拿锁演示

public class Demo2 {
    public static void main(String[] args) {
        S1 s1 = new S1();
        S2 s2 = new S2();

        Thread b = new Thread( new ThreadB(s1,s2) );
        Thread a = new Thread( new ThreadA(s1, s2) );

        b.start();
        a.start();
    }
}

class S1{
    public int a=1;
}
class S2{
    public int a=2;
}

public class ThreadA implements Runnable{
    private S1 s1 = null;
    private S2 s2 = null;

    public ThreadA(S1 s1, S2 s2) {
        this.s1 = s1;
        this.s2 = s2;
    }

    @Override
    public void run() {
        System.out.println("ThreadA begin......");
        synchronized (s1) {
            System.out.println("ThreadA拿到对象锁1:"+s1.a);

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("ThreadA睡醒，准备拿对象锁2...");
            synchronized (s2) {
                System.out.println("ThreadA手握对象锁1和锁2，进行工作..."+s2.a);
            }
        }
    }

}

public class ThreadB implements Runnable{
    private S1 s1 = null;
    private S2 s2 = null;

    public ThreadB(S1 s1, S2 s2) {
        this.s1 = s1;
        this.s2 = s2;
    }

    @Override
    public void run() {
        System.out.println("ThreadB begin......");
        synchronized (s2) {
            System.out.println("ThreadB拿到对象锁2:"+s2.a);

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("ThreadB睡醒，准备拿对象锁1...");
            synchronized (s1) {
                System.out.println("ThreadB手握对象锁1和锁2，进行工作..."+s1.a);
            }
        }
    }

}

执行结果:

线程中的各种方法

1. sleep()方法
   Thread类的sleep()方法对当前线程操作，是静态方法。sleep()的参数指定以毫秒为单位的线程休眠时间。除非因为中断而提早恢复执行，否则线程不会在这段时间之前恢复执行。
2. interrupt()方法
   一个线程可以调用另外一个线程的interrupt()方法，这将向暂停的线程发出一个InterruptedException。变相起到唤醒暂停线程的功能。Thread类的方法interrupt()，是一种强制唤醒的技术。
3. yield()方法
   用来使具有相同优先级的线程获得执行的机会。如果具有相同优先级的其它线程是可运行的，yield()将把线程放到可运行池中并使另一个线程运行。如果没有相同优先级的可运行线程，则什么都不做。
   注意，执行一次yield()方法，该线程只是放弃当前这一次机会，然后又会重新和其它线程一起抢占CPU，很可能又比其它线程先抢到。
4. join()方法
   调用某线程的该方法，将当前线程与该线程“合并”，即等待该线程结束，再恢复当前线程的运行。它可以实现线程合并的功能，经常用于线程的绝对调度。
5. wait()方法
   当前线程进入对象的wait pool。
6. notify()/notifyAll()方法
   唤醒对象的wait pool中的一个/所有等待线程。