多线程的一些基础知识

关于创建线程的两种方式：

一：利用Thread类创建线程

Thread类声明在java.lang包中，其中封装了创建和控制线程操作的所有成员方法。如果需要创建线程应该先声明一个Thread的子类，并且覆盖其中的run()成员方法，并将线程执行的程序代码写在其中。注意，尽管在Thread的子类中覆盖了run()成员方法，但用户不能直接调用它，而是需要通过Thread类提供的start()成员方法间接的调用它。（若直接调用run()方法，相当于调用了一个普通的方法）

二：利用Runnable接口创建线程

java只支持单继承，为了解决这个问题，java提供了另一种声明线程的途径，实现Runnable接口。(1)定义一个实现Runnable接口的类，并实现run()方法，并将线程执行的程序代码写在其中。(2)以实现Runnable接口的对象为参数创建一个Thread类对象(3)调用Thread类对象的start()方法启动线程。

关于Thread的构造方法：
Thread()
Thread(Runnable target)
Thread(Runnable target, String name)
Thread(String name)
Thread(ThreadGroup group, Runnable target)
Thread(ThreadGroup group, Runnable target, String name)
Thread(ThreadGroup group, Runnable target, String name, long stackSize)
Thread(ThreadGroup group, String name)
其中，target表示实际执行线程的目标对象，它必须实现接口Runnable，name是线程名。group指出线程所属的线程组。
下面给出两个小栗子：

public class MYThread_1 extends Thread{     // 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，     // 一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。    public void run(){        synchronized (this){            for(int i=1;i<5;i++){                for(int j=0;j<8;j++){                    System.out.print(Thread.currentThread().getName() + "(" + j + ")");                }                System.out.println();            }            System.out.println("exit from  " + Thread.currentThread().getName());            System.out.println("----------" + Thread.currentThread().getId() + "\n");        }    }    public static void main(String[]args){//      这部分演示线程的交替执行//      Thread t1=new MYThread_1();t1.setName("T1");//      Thread t2=new MYThread_1();t2.setName("T2");//      t1.start();//      t2.start();        //这部分演示线程的顺序执行，同一个对象synchronized关键字起作用        MYThread_1 t1=new MYThread_1();        Thread z=new Thread(t1);z.setName("z");        Thread zz=new Thread(t1);zz.setName("zz");        z.start();zz.start();        System.out.println("exit from" + Thread.currentThread().getName());        System.out.print("----------"+Thread.currentThread().getId()+"\n");    }}

public class MYThread_2 implements Runnable{    public void run(){        for(int i=1;i<=10;i++){            System.out.println(Thread.currentThread().getName()+"running///"+i);        }    }    public static void main(String[]args){        MYThread_2 thread=new MYThread_2();        Thread myThread=new Thread(thread);        myThread.setName("yxl-->");        Thread zzx=new Thread(thread,"zzy-->");        //zzx.setName("zzy-->");        myThread.start();        zzx.start();    }}

关于wait和notify、notifyAll

关于sleeo()和wait()的区别

它们最大本质的区别是:sleep()不释放同步锁,wait()释放同步锁.
还有用法的上的不同是:sleep(milliseconds)可以用时间指定来使他自动醒过来,
如果时间不到你只能调用interreput()来强行打断;wait()可以用notify()直接唤起.
1。这两个方法来自不同的类分别是Thread和Object
2。最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
3。wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用

synchronized(x){  x.notify()  //或者wait() }

4。sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
下面给个小栗子：

public class Try_Wait_Notify implements Runnable{    public void run(){        synchronized(this){            for(int i=1;i<=100;i++){                System.out.print(Thread.currentThread().getName()+":"+i+"  ");                if(i%10==0){                    System.out.println();                    try{                        notifyAll();                        if(i==100)                            break;                        else                            wait();//Thread.sleep(1000);                    }catch(InterruptedException e){                        //do something                    }                }            }        }    }    public static void main(String[]args){        Try_Wait_Notify share=new Try_Wait_Notify();        Thread t1=new Thread(share,"t1");        Thread t2=new Thread(share,"t2");        t1.start();        t2.start();    }}

关于线程的优先级及其调度

在java程序中，每一个线程都有一个优先级，可以调用Thread的setPriority()成员方法来设置线程的优先级，在Thread类中海油三个常量Thread.MIN_PRIORITY，Thread.MAX_PRIORITY，Thread.NORM_PRIORITY，她们分别表示优先级为1、10、5，她们分别代表最低优先级，最高优先级，普通优先级。注意：java程序中使用的线程优先级依赖于运行java程序的环境，当运行系统的优先级与java设置的优先级有差别时，java中的优先级将会被映射成运行系统的优先级。因此，建议不要让程序的执行完全依赖于线程的优先级。

关于sleep、join

写一个小栗子：
javaBean：

public class Computer{    private int price;    private String name;    public Computer() {    }    public Computer(int price, String name){        this.price=price;        this.name=name;    }    public void setName(String name) {        this.name = name;    }    public void setPrice(int price) {        this.price = price;    }    public String getName() {        return name;    }    public int getPrice() {        return price;    }    @Override    public String toString() {        return "Computer{" +                "price=" + price +                ", name='" + name + '\'' +                '}';    }}

test Sleep Join method：

public class Try_Sleep_Join implements Runnable{    private Computer computer;    public Thread customer,maker;    Try_Sleep_Join(){        customer=new Thread(this);        maker=new Thread(this);        customer.setName("student");        maker.setName("computer maker");    }    //Thread.currentThread()方法返回的是线程对象，Thread.currentThread().getName返回的是线程的名字    public void run(){        if(Thread.currentThread()==customer){            System.out.println(customer.getName()+" wait "+maker.getName()+" maker computer.");            try{                maker.join();                //一个线程A调用另一个线程B的join方法，可以使线程A                //暂时停止运行，直至线程B终止。但是如果B线程已经运行结束，                //则B.join不会产生任何结果，利用join方法可以实现线程之间的同步。            }catch(InterruptedException e){                //do something            }            System.out.println(customer.getName()+" buy a computer:"+computer.getName()+" price "+computer.getPrice());        }        else if(Thread.currentThread()==maker){            System.out.println(maker.getName()+" begin to maker computer,please wait...");            try{                Thread.sleep(2000);            }catch(InterruptedException e){                //do something            }            computer=new Computer(4888,"lenovo");            System.out.println(maker.getName()+"maker over!");        }    }}

测试类：

public class Test_Try_Slepp_Join {    public static void main(String[]args){        Try_Sleep_Join t=new Try_Sleep_Join();        t.maker.start();        t.customer.start();    }}

关于线程让步：

当多个线程之间需要合作完成一项任务时，可以利用yield()方法来强制线程间的合作。这个方法可以使一个线程让出CPU给其他可运行的线程运行，当前线程等待调用该方法的线程运行结束后，再恢复这行。如果当前没有其他可以运行的线程，yield()方法什么都不做。

判断线程是否处于活动状态：

Thread类中的isAlive()方法用于判断线程是否处于活动状态。