关于java中的多线程

1、线程的5种状态

(1)、创建状态：即创建线程，Thread thread=new Thread();

(2)、就绪状态：创建线程对象后调用start()方法，即可启动线程，当线程启动时，线程就进入的就绪状态。线程将进入线程队列排队，等待CPU服务。

(3)、运行状态：就绪状态被调用，线程就进入了运行状态，会自动调用该线程的run()方法。

(4)、阻塞状态：在运行状态下如果调用了sleep()、wait()、suspend()等方法线程都将会进入阻塞状态，只有阻塞原因消除后，线程才可以进入到就绪状态。

(5)、死亡状态：当调用了stop()方法，或者run()方法执行完毕后，线程就进入了死亡状态

java程序每次启动时，至少启动两个线程，分别是main线程和垃圾回收机制

2、中断线程

当一个线程运行时，另外一个线程可以直接通过interrupt()方法中断其运行状态。

class MyThread implements Runnable{ // 实现Runnable接口 
    public void run(){  // 覆写run()方法 
        System.out.println("1、进入run()方法") ; 
        try{ 
            Thread.sleep(10000) ;   // 线程休眠10秒 
            System.out.println("2、已经完成了休眠") ; 
        }catch(InterruptedException e){ 
            System.out.println("3、休眠被终止") ; 
            return ; // 返回调用处 
        } 
        System.out.println("4、run()方法正常结束") ; 
    } 
}; 
public class ThreadInterruptDemo{ 
    public static void main(String args[]){ 
        MyThread mt = new MyThread() ;  // 实例化Runnable子类对象 
        Thread t = new Thread(mt,"线程");     // 实例化Thread对象 
        t.start() ; // 启动线程 
        try{ 
            Thread.sleep(2000) ;    // 线程休眠2秒 
        }catch(InterruptedException e){ 
            System.out.println("3、休眠被终止") ; 
        } 
        t.interrupt() ; // 中断线程执行 
    } 
};

3、后台线程

在 Java 程序中，只要前台有一个线程在运行，则整个 Java 进程都不会消失，所以此时可以设置一个后台线程，这样即使 Java 线程结束了，此后台线程依然会继续执行，要想实现这样的操作，直接使用 setDaemon() 方法即可。

class MyThread implements Runnable{ // 实现Runnable接口 
    public void run(){  // 覆写run()方法 
        while(true){ 
            System.out.println(Thread.currentThread().getName() + "在运行。") ; 
        } 
    } 
}; 
public class ThreadDaemonDemo{ 
    public static void main(String args[]){ 
        MyThread mt = new MyThread() ;  // 实例化Runnable子类对象 
        Thread t = new Thread(mt,"线程");     // 实例化Thread对象 
        t.setDaemon(true) ; // 此线程在后台运行 
        t.start() ; // 启动线程 
    } 
};

4、线程同步

synchronized(同步对象){

需要同步的代码块

}

class MyThread implements Runnable{ 
    private int ticket = 5 ;    // 假设一共有5张票 
    public void run(){ 
        for(int i=0;i<100;i++){ 
            synchronized(this){ // 要对当前对象进行同步 
                if(ticket>0){   // 还有票 
                    try{ 
                        Thread.sleep(300) ; // 加入延迟 
                    }catch(InterruptedException e){ 
                        e.printStackTrace() ; 
                    } 
                    System.out.println("卖票：ticket = " + ticket-- ); 
                } 
            } 
        } 
    } 
}; 
public class SyncDemo02{ 
    public static void main(String args[]){ 
        MyThread mt = new MyThread() ;  // 定义线程对象 
        Thread t1 = new Thread(mt) ;    // 定义Thread对象 
        Thread t2 = new Thread(mt) ;    // 定义Thread对象 
        Thread t3 = new Thread(mt) ;    // 定义Thread对象 
        t1.start() ; 
        t2.start() ; 
        t3.start() ; 
    } 
};
  
  


  
  

也可以将方法同步

在需要同步的方法前加上synchronized 关键字

class MyThread implements Runnable{ 
    private int ticket = 5 ;    // 假设一共有5张票 
    public void run(){ 
        for(int i=0;i<100;i++){ 
            this.sale() ;   // 调用同步方法 
        } 
    } 
    public synchronized void sale(){    // 声明同步方法 
        if(ticket>0){   // 还有票 
            try{ 
                Thread.sleep(300) ; // 加入延迟 
            }catch(InterruptedException e){ 
                e.printStackTrace() ; 
            } 
            System.out.println("卖票：ticket = " + ticket-- ); 
        } 

    } 
}; 
public class SyncDemo03{ 
    public static void main(String args[]){ 
        MyThread mt = new MyThread() ;  // 定义线程对象 
        Thread t1 = new Thread(mt) ;    // 定义Thread对象 
        Thread t2 = new Thread(mt) ;    // 定义Thread对象 
        Thread t3 = new Thread(mt) ;    // 定义Thread对象 
        t1.start() ; 
        t2.start() ; 
        t3.start() ; 
    } 
};

原文章地址：

http://blog.csdn.net/lijizhi19950123

class MyThread implements Runnable{ 
    private int ticket = 5 ;    // 假设一共有5张票 
    public void run(){ 
        for(int i=0;i<100;i++){ 
            synchronized(this){ // 要对当前对象进行同步 
                if(ticket>0){   // 还有票 
                    try{ 
                        Thread.sleep(300) ; // 加入延迟 
                    }catch(InterruptedException e){ 
                        e.printStackTrace() ; 
                    } 
                    System.out.println("卖票：ticket = " + ticket-- ); 
                } 
            } 
        } 
    } 
}; 
public class SyncDemo02{ 
    public static void main(String args[]){ 
        MyThread mt = new MyThread() ;  // 定义线程对象 
        Thread t1 = new Thread(mt) ;    // 定义Thread对象 
        Thread t2 = new Thread(mt) ;    // 定义Thread对象 
        Thread t3 = new Thread(mt) ;    // 定义Thread对象 
        t1.start() ; 
        t2.start() ; 
        t3.start() ; 
    } 
};
  
  


  
  

class MyThread implements Runnable{ 
    private int ticket = 5 ;    // 假设一共有5张票 
    public void run(){ 
        for(int i=0;i<100;i++){ 
            this.sale() ;   // 调用同步方法 
        } 
    } 
    public synchronized void sale(){    // 声明同步方法 
        if(ticket>0){   // 还有票 
            try{ 
                Thread.sleep(300) ; // 加入延迟 
            }catch(InterruptedException e){ 
                e.printStackTrace() ; 
            } 
            System.out.println("卖票：ticket = " + ticket-- ); 
        } 

    } 
}; 
public class SyncDemo03{ 
    public static void main(String args[]){ 
        MyThread mt = new MyThread() ;  // 定义线程对象 
        Thread t1 = new Thread(mt) ;    // 定义Thread对象 
        Thread t2 = new Thread(mt) ;    // 定义Thread对象 
        Thread t3 = new Thread(mt) ;    // 定义Thread对象 
        t1.start() ; 
        t2.start() ; 
        t3.start() ; 
    } 
};