Java线程总结

 1、线程优先级

线程的优先级分为10级，分别用1到10的整数代表，默认情况是5。上面的t2.setPriority(Thread.MAX_PRIORITY)等价与t2.setPriority(10）

public class MyThread implements Runnable
{

public void run()
{
System.out.println("My Name is "+Thread.currentThread().getName());
}
public static void main(String[] args)
{
Thread t1=new Thread(new MyThread());
Thread t2=new Thread(new MyThread());
Thread t3=new Thread(new MyThread());
t2.setPriority(Thread.MAX_PRIORITY);//赋予最高优先级
t1.start();
t2.start();
t3.start();
}
}

2、线程睡眠

public class MyThread implements Runnable {
    public void run() {
        try {
            int sleepTime = (int) (Math.random() * 100);// 产生随机数字，
            Thread.currentThread().sleep(sleepTime);// 让其休眠一定时间，时间又上面sleepTime决定
            // public static void sleep(long millis)throw InterruptedException
            // （API）
            System.out.println(Thread.currentThread().getName() + " 睡了 "
                    + sleepTime);
        } catch (InterruptedException ie)// 由于线程在休眠可能被中断，所以调用sleep方法的时候需要捕捉异常
        {
            ie.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread());
        Thread t2 = new Thread(new MyThread());
        Thread t3 = new Thread(new MyThread());
        t1.start();
        t2.start();
        t3.start();
    }
}

3、线程组

 

public class MyThread implements Runnable {
    public void run() {
        try {
            int sleepTime = (int) (Math.random() * 100);// 产生随机数字，
            Thread.currentThread().sleep(sleepTime);// 让其休眠一定时间，时间又上面sleepTime决定
            // public static void sleep(long millis)throw InterruptedException
            // （API）
            System.out.println(Thread.currentThread().getName() + " 睡了 "
                    + sleepTime);
        } catch (InterruptedException ie)// 由于线程在休眠可能被中断，所以调用sleep方法的时候需要捕捉异常
        {
            ie.printStackTrace();
        }
    }

    public static void main(String[] args)  {
    /***************************************
    ThreadGroup(String name)
    ThreadGroup(ThreadGroup parent, String name)
    ***********************************/
    ThreadGroup group1=new ThreadGroup("group1");
    ThreadGroup group2=new ThreadGroup(group1,"group2");
    Thread t1=new Thread(group2,new MyThread());
    Thread t2=new Thread(group2,new MyThread());
    Thread t3=new Thread(group2,new MyThread());
    t1.start();
    t2.start();
    t3.start();
    }

}

4、共享

可能你注意到了在使用wait and notify方法得时候我使用了synchronized块来包装这两个方法，这是由于调用这两个方法的时候线程必须获得锁，也就是上面代码中的lock[]，如果你不用synchronized包装这两个方法的得话，又或则锁不一是同一把，比如在MyThread_2中synchronized(lock)改为synchronized(this),那么执行这个程序的时候将会抛出java.lang.IllegalMonitorStateException执行期异常。另外wait and notify方法是Object中的，并不在Thread这个类中。最后你可能注意到了这点：int[] in=new int[0];为什么不是创建new Object而是一个0长度的数组，那是因为在java中创建一个0长度的数组来充当锁更加高效。

class MyThread_1 extends Thread {
    Object lock;

    public MyThread_1(Object o) {
        lock = o;
    }

    public void run() {
        try {
            synchronized (lock) {
                System.out.println("Enter Thread_1 and wait");
                lock.wait();
                System.out.println("be notified");
            }
        } catch (InterruptedException e) {
        }
    }
}

class MyThread_2 extends Thread {
    Object lock;

    public MyThread_2(Object o) {
        lock = o;
    }

    public void run() {
        synchronized (lock) {
            System.out.println("Enter Thread_2 and notify");
            lock.notify();
        }
    }
}

public class MyThread {
    public static void main(String[] args) {
        int[] in = new int[0];// notice
        MyThread_1 t1 = new MyThread_1(in);
        MyThread_2 t2 = new MyThread_2(in);
        t1.start();
        t2.start();
    }
}