java线程

多线程编程示提高应用程序性能的重要手段之一，java平台从刚开始就被设计为多线程环境，从语言级上支持多线程。在java语言中，提供了创建/启动/调度/同步等各种线程管理方法。多线程的最大目的是最大限度的利用cpu资源。当某一线程的处理不再需要占用cpu，而之和I/O、内存等资源打交道时，让需要占用cpu资源的其他线程有机会获得cpu资源。
要完全的掌握多线程编程，需要弄清进程和线程的区别。进程是个动态的过程，示程序的一次执行，进程用户表示程序在内存环境中执行的基本单元。（具体的 区别希望读者自己去分析）
1.创建线程，创建线程有两种方式 ，第一可以继承java.lang.Thread类，第二实现Runable接口。
    继承Thread，用户可以通过继承Thread类，覆盖其run方法创建自己的线程类

        class MyThread extends Thread{
            public void run(){
                for(int i = 0;i < 10;i++){
                    System.out.pritnln(i);
                    }
                }        
        }//定义一个简单的线程类MyThread，继承了Thread，并且覆盖了其run方法。

    
    实现Runable接口，如果自定义的线程类还要继承其他类，这时候就不能采用上一种方法来创建了。由于java语言不支持类的多继承，却可以实现多个接口，所以这种情况就可以通过Runable接口的方式创建。

        class MyThread implements Runable{
        public void run(){
            SYstem.out.println("hello");
        }
        }

其实Thread类也是实现了Runable接口。

2.启动线程
    继承Thread类方式线程的启动
    继承Thread类方式的线程启动非常简单，只要创建线程类实例之后调用起start()方法。
 

  ThreadClass ThreadInstace = new TreadClass();
    ThreadInstance.start();
    例子：
        Class MyThread extends Thread{
            publci void run(){
                for(int i = 0;i<10;i++){
                    System.out.println(i);
                }
            }
        }
        public class Test{
            public static void main(String[] args){
                MyThread t = new MyThread();
                t.start();
            }
        }

    实现Runable接口线程的启动，实现Runable接口创建的线程首先转换为Thread类，然后调用Thread类的start()方法启动线程。
    例子：
  

     class MyThread implements Runable{
            publci void run(){
                for(int i = 0 ; i < 10 ; i++){
                    System.out.println(i);
                }
            }
        }
        public class Test{
            public static void main(String args[]){
                MyThread mt = new MyThread();
                Thread t = new Thread(mt);
                t.start();
            }
        }

3.线程的生命周期
线程从创建到死亡具有一个完整的生命周期，在整个生命周期中处于各种状态，线程的状态表明线程当前可以进行的活动，一个生命周期内的线程主要包括创建、就绪、运行、阻塞、死亡状态
    创建
    线程使用new关键字实例化之后且在调用start之前，线程处于创建状态，处于创建状态的线程仅仅分配了内存空间，属于生命周期的初始状态
    就绪
    在线程调用了start方法之后即处于就绪状态，处于就绪状态的线程具有了除CPU之外运行所需要的所有资源，就绪状态线程排队等待cpu，由系统调度为其分配
    运行
    处于就绪状态的线程获得cpu之后即处于运行状态，处于运行状态的线程才开始正真执行线程run()方法的内容
    阻塞
    处于运行状态的线程如果因为某种原因不能继续执行，则进入阻塞状态。阻塞状态与就绪状态不同的是：就绪状态只是因为缺少cpu而不能执行，而阻塞状态是由于各种原因引起线程不能执行，不仅仅是缺少cpu，引起阻塞的原因解除之后，线程再次转换为就绪状态，等待分配cpu运行。
    死亡
    当线程执行完run()方法的内容或被强制终止时，线程处于死亡状态，线程的整个生命周期结束。

4.线程的调度
处于生命周期中的线程，通过调度实现各种状态间的转换。
    线程的优先级
    线程的优先级是指线程在被系统调度执行时的优先执行级别，在多线程程序中，往往示多个线程同时等待被调度执行，然而，每个线程的重要程度通常不一样，在同等条件下，有些重要线程需要优先执行，在java语言中，通过调用setPriority()方法为线程设置优先级，优先级用1-10的数字表示，数字越大，优先级越高。
    例子：
   

    class MyThread extends Thread{
            public void run(){
                for(int i = 0; i < 10 ; i++){
                    System.out.println(i);    
                }
            }
        }
        publci class test{
            public static void main(String args[]){
                MyThread t1 = new MyThread();
                MyThread t2 = new MyThread();
                
                t1.setPriority(1);
                t2.setPriority(10);

                t1.start();
                t2.start();
            }
        }

    线程休眠sleep()
    对于正在执行的线程，可以调用sleep()方法使其放弃cpu进行休眠，此线程为阻塞状态。sleep()方法包含long型的参数，用于指定线程休眠的时间，单位微为毫秒。sleep()方法会抛出异常。

    class MyThread extends Thread{
        public void run(){
            for(int i = 0 ; i < 9 ; i++){
                System.out.println(i);
                try{
                    sleep(1000);
                }
                catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    }
    public class test{
        public static void main(String args[]){
            MyThread t= new MyThread();
            t.start();
        }
    }

   
    线程让步yield()
    对于着呢挂在执行的线程，可以调用yield方法使其重新排队，将cpu让给排在后面的线程，此线程转换为就绪状态。另外，yield()方法只让步给高优先级或同等优先级的线程，如果后面是低优先级线程，则继续执行此线程。yield()没有参数，也没有申明抛出任何异常。
    实例：
 

   class MyThread extends Thread{
        public void run(){
            for(int i =0 ; i < 10 ; i++){
                System.out.println(i);
            }
        }
    }
    public class test(){
        public static void main(String args[]){
            MyThread t1= new MyThread();
            MyThread t2= new MyThread();

            t1.start();
            t2.start();
        }    
    }

    线程等待join()
    对于正在执行的线程，可以调用join()方法等待其结束，然后才执行其他程序。join()方法有几种重载形式。

    class MyThread extends Thread{
        public void run(){
            for(int i =0 ; i < 10 ; i++){
                System.out.println(i);
            }
        }
    }
    public class test(){
        public static void main(String args[]){
            MyThread t1= new MyThread();
            MyThread t2= new MyThread();

            t1.start();
            t1.join();
            t2.start();
        }    
    }

4.线程同步
当多个线程操作同一个共享资源时，比如读写同一个变量，存在资源竞争的问题，为了解决此类问题，需要使用同步机制。在java语言中，利用synchronized关键字实现线程的同步。
    多线程资源竞争的举例
 

   class MyThread implements Runable{
        private int count = 0;
        
        public void run(){
            test();
        }

        public void test(){
            for(int i = 0;i< 10;i++){
                count++;
                Thread.yield();
                count--;
                System.out.println(count);
            }
        }
    }
    public class Test(){
        public static void main(String args[]){
            MyThread mt = new MyThread();
            Thread t1 = new Thread(mt);
            Thread t2 = new THread(mt);
            t1.start();
            t2.start();
        }
    } 

  
    由于同时启动两个线程，变量count对这两个线程示共享的，在不同时刻，每个线程都可能在对变量count执行自加自减，为了解决这个问题，可以用关键字synchronized对代码快进行锁定，确保优先成开始执行时首先对其进行锁定，其他线程此时不能执行该段代码，直到当线程执行完解除锁定。如在上面的例子中，在test()方法在定义的时候加上；
    private void synchronized test()
其他代码不变。

江苏南京  钟志远      904727147