Java进程--简单讲解

线程和进程

• 进程：在操作系统中能（同时）运行多个任务（程序），每一个应用程序就是进程。
• 线程：在一个程序中同时运行额多个独立流程，每一个独立的流程就是一个线程。
• 每一个Java程序都至少有一个线程–主线程，当一个Java程序启动时，JVM会创建这个主线程，并且在这个主线程上调用main()方法。
• 线程并发：多个线程同时执行（多个线程轮流分配cpu的时间片，并不是真正的同时执行)。
  

线程开发

• 线程开发有两种方式：
  
  • 继承Thread类
  • 实现Runnable接口

继承Thread类

• 继承Thread类开发线程

  • 用户定义一个类继承Thread类
  • 覆盖run方法

  • 运行线程

     class MyThread extends Thread{     public void run(){         for(int i =1; i<=1000; i++) {             System.out.println(i+"$$$");         }    }}class MyThread2 extends Thread{    public void run() {        for(int i=1; i<=1000; i++) {            System.out.println(i+"###");        }    }}

---

    public class TestThread {        public static void main(String args[]) {            Thread t1 = new MyThread1();            Thread t2 = new MyThread2();            //启动线程，输出顺序是随机的            t1.start();            t2.start();        }    }

实现Runnable接口

• Runnable接口开发线程
  
  • 用户开发一个类实现Runnable接口
  • 实现run();
  • 运行线程
    Runnable target = newMyRunnable2();
Thread t2 = new Thread(target);

示例

    class MyThread1 extends Thread {        public void run() {            for(int i = 1; i<=1000; i++ ) {                System.out.pintln(i+"$$$");            }        }    }    class MyRunnable2 implements Runnable {        public void run() {            for(int i = 1; i<=1000; i++) }                System.out.println(i+"###");            }        }    }    public class TestThread {        //第一种方式        Thread t1 = new MyRunnable1();        //第二种方式        Runnable target = new MyRunnale2();        Thread t2 = new Thread(target);        t1.start();        t2.start();    }} 

两种方式对比

• 继承Thread上面向对象的编程方式
• 实现Runnable接口解决了单一继承的限制

• 二者都可采用匿名内部类的方式，如果线程只在一处使用，可以选择这种方式，但是可读性较差。

   new Thread() {     @Override     public void run() {         for(int i = 1; i<=1000; i++) {             System.out.println(i+"$$$");        }    }}.start();new Thread(new Runnable() {    @Overrider    public void run() {        for(int i = 1; i<=1000; i++) {            System.out.println(i+"###");        }    }}).start();

线程的状态

• 线程的状态分为5种，初始、可运行、运行、阻塞、以及终止等。
  

线程的调度与控制

• 通常我们的计算机知识一个CPU，CPU在某一个时刻只能执行一条指令，线程知识得到CPU时间片，也就是使用权，才可以执行指令。在单CPU的机器上线程不是并行运行的，只有在多个CPU的使用权，目前按有两种调度模型：分时调度模型和抢占式调度模型，Java使用抢占式调度模型。
  
  • 分时调度模型，所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU时间片。
  • 抢占式调度模型，优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个。

线程优先级

• 线程优先级主要分三种

  • MAX_PRIORITY(最高级);
  • MIN_PRIOITY(最低级);

  • NOM_PRIORITY(标准)默认；

    public class ThreadTest04 {    public static void main(String[] args) {        Runnable r1 = new Processor();        Thread t1 = new Thread(r1, "t1");        //设置线程的优先级，线程启动后不能再次设置优先级        //必须在启动前设置优先级        //设置最高优先级        t1.setPriority(Thread.MAX_PRIORITY);        //启动线程        t1.start();        //取得线程名称        //System.out.println(t1.getName());        Thread t2 = new Thread(r1, "t2");        //设置最低优先级        t2.setPriority(Thread.MIN_PRIORITY);        t2.start();            System.out.println(Thread.currentThread().getName());    }   }

---

    class Processor implements Runnable {           public void run() {              for (int i=0; i<100; i++) {                     System.out.println(Thread.currentThread().getName() + "," + i);              }             }       }    /**     *从输出结果应该看可以看出，     *优先级高的线程（t1）会得到的     *CPU时间多一些，优先执行完成     **/

sleep和join还有yeild

Thread.sleep

• sleep设置休眠的时间,单位毫秒，当一个线程遇到sleep的时候，就会睡眠，进入到阻塞状态,放弃CPU，腾出cpu时间片，给其他线程用，所以在开发中通常我们会这样做，使其他的线程能够取得CPU时间片，当睡眠时间到达了，线程会进入就绪状态，得到CPU时间片继续执行，如果线程在睡眠状态被中断了，将会抛出IterruptedException

      public class ThreadTest05 {        public static void main(String[] args) {            Runnable r1 = new Processor();            Thread t1 = new Thread(r1, "t1");            t1.start();            Thread t2 = new Thread(r1, "t2");            t2.start();        }       }    class Processor implements Runnable {           public void run() {            for (int i=0; i<100; i++) {        System.out.println(Thread.currentThread().getName() + "," + i);            if (i % 10 == 0) {            try {                //睡眠100毫秒，主要是放弃CPU的使用，将CPU时间片交给其他线程使用                Thread.sleep(100);            }catch(InterruptedException e) {                e.printStackTrace();                }        }    }   }   

  }

Thread.join

• 当前线程可以调用另一个线程的join方法，调用后当前线程会被阻塞不再执行，直到被调用的线程执行完毕，当前线程才会执行

      public class ThreadTest07 {        public static void main(String[] args) {            Runnable r1 = new Processor();            Thread t1 = new Thread(r1, "t1");            t1.start();            try {                t1.join();            }catch(InterruptedException e) {                    e.printStackTrace();                }            System.out.println("------main end-------");        }   }class Processor implements Runnable {        public void run() {            for (int i=0; i<10; i++) {                System.out.println(Thread.currentThread().getName() + "," + i);            }       }   }

Thread.yield

• 它与sleep()类似，只是不能由用户指定暂定多长时间，并且yield()方法只能让同优先级的西安城有执行的机会。

      public class ThreadTest06 {        public static void main(String[] args) {            Runnable r1 = new Processor();            Thread t1 = new Thread(r1, "t1");            t1.start();            Thread t2 = new Thread(r1, "t2");            t2.start();        }       }    class Processor implements Runnable {        public void run() {            for (int i=0; i<100; i++) {                System.out.println(Thread.currentThread().getName() + "," + i);                if (i % 10 == 0) {                    System.out.println("--------------");                    //采用yield可以将CPU的使用权让给同一个优先级的线程                    Thread.yield();            }        }       }   }

sleep、join、yeild关系

• sleep()使当前线程进入停滞状态，所以执行sleep的线程在指定的时间内肯定不会执行；sleep()可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会。
• join方法也会导致线程阻塞
  
  • 特点：如果当前线程中调用了另外一个线程的join方法，单签线程会立即阻塞，直到另外一个线程运行完成。
• yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行，yield()只能使同优先级的线程有执行的机会。

interrupt(中断)

• 如果我们的线程正在睡眠，可以采用interrupt进行中断

       public class ThreadTest08 {        public static void main(String[] args) {            Runnable r1 = new Processor();            Thread t1 = new Thread(r1, "t1");            t1.start();            try {                //设置为500毫秒，没有出现中断异常，因为500毫秒之后再次调用t1.interrupt()时，                //此时的睡眠线程已经执行完成                //如果sleep的时间设置的小一些，会出现中断异常，因为存在睡眠线程                Thread.sleep(500);            }catch(Exception e) {                e.printStackTrace();            }        //中断睡眠中的线程        t1.interrupt();    }   }class Processor implements Runnable {       public void run() {        for (int i=1; i<100; i++) {            System.out.println(Thread.currentThread().getName() + "," + i);            if (i % 50 == 0) {                try {                    Thread.sleep(200);                  }catch(Exception e) {                    System.out.println("-------中断-------");                    break;                              }            }        }       }   }

如何正确的停止一个线程

• 通常定义一个标记，来判断标记的状态停止线程的执行。

       public class ThreadTest09 {        public static void main(String[] args) {            //Runnable r1 = new Processor();            Processor r1 = new Processor();            Thread t1 = new Thread(r1, "t1");            t1.start();        try {            Thread.sleep(20);        }catch(Exception e) {}            //停止线程            r1.setFlag(true);        }       }    class Processor implements Runnable {           //线程停止标记，true为停止        private boolean flag;        public void run() {            for (int i=1; i<100; i++) {                System.out.println(Thread.currentThread().getName() + "," + i);                //为true停止线程执行                if (flag) {                    break;                }            }           }    public void setFlag(boolean flag) {        this.flag = flag;    }   }

为什么需要同步

• 【示例代码】，取得0~10的和采用相同的线程对象启用两个线程进行计算（共享一个对象启动两个线程）

          public class ThreadTest10 {            public static void main(String[] args) {                Runnable r1 = new Processor();                Thread t1 = new Thread(r1, "t1");                t1.start();                Thread t2 = new Thread(r1, "t2");                t2.start();        }       }    class Processor implements Runnable {               public void run() {                //定义局部变量s，作为累加变量                int s = 0;                for (int i=0; i<10; i++) {                    s+=i;                }               System.out.println(Thread.currentThread().getName() + ", s=" + s);        }}

  以上t1和t2并发执行，s为每个线程的局部变量，位于各自的栈帧中，因为栈帧中的数据是不会互相干扰的，所有计算结果都为45

线程同步

• 【示例代码】，取得0~10的和采用两个线程进行计算，将s改为成员变量(共享一个对象启动两个线程)

      public class ThreadTest11 {        public static void main(String[] args) {            Runnable r1 = new Processor();            Thread t1 = new Thread(r1, "t1");            t1.start();            Thread t2 = new Thread(r1, "t2");            t2.start();    }   }class Processor implements Runnable {    //定义成员变量s，作为累加变量        private int s = 0;      public void run() {        for (int i=0; i<10; i++) {            s+=i;        }           System.out.println(Thread.currentThread().getName() + ", s=" + s);    }}

  这回两个线程的结果不一致了。为什么出现以上的问题，因为共享了同一个对象的成员变量s，两个线程同时对其进行操作，所以产生了问题，此时称为此时Processor为线程不安全的，如果想得到正确的结果，必须采用线程同步，加锁，该变量才能共享使用

• 产生数据不一致的原因
  
  • 多个线程并发访问了同一个对象，如果破坏了不可分割的操作，从而就会造成数据不一致
• 临界资源
• 原子操作
• 被多线程并发访问时如果一个对象有可能出现数据不一致的问题，那么这个对象称为线程不安全的对象

使用线程同步

• 线程同步，指某一个时刻，指允许一个线程来访问共享资源，线程同步其实是对对象加锁，如果对象中的方法都是同步方法，那么某一时刻只能执行一个方法，采用线程同步解决以上的问题，我们只要保证线程1操作s时，线程2不允许操作即可，只有线程1使用完成s后，再让线程2使用s变量。

  public class ThreadTest12 {    public static void main(String[] args) {        Runnable r1 = new Processor();        Thread t1 = new Thread(r1, "t1");        t1.start();             Thread t2 = new Thread(r1, "t2");        t2.start();    }   }class Processor implements Runnable {    //定义成员变量s，作为累加变量        private int s = 0;      //synchronized是对对象加锁,采用synchronized同步最好只同步有线程安全的代码    //可以优先考虑使用synchronized同步块因为同步的代码越多，执行的时间就会越长，    //其他线程等待的时间就会越长影响效率    //public synchronized void run() {        //使用同步块        synchronized (this) {             for (int i=0; i<10; i++) {                s+=i;            }               System.out.println(Thread.currentThread().getName() + ", s=" + s);            s = 0;        }    }}

执行正确 ，以上示例，如果不采用线程同步如何解决？可以让每个线程创建一个对象，这样在堆中就不会出现对象的状态共享了，从而可以避免线程安全问题

线程同步后的状态

为每一个线程创建一个对象来解决线程安全问题

    public class ThreadTest13 {        public static void main(String[] args) {            Runnable r1 = new Processor();            Thread t1 = new Thread(r1, "t1");            t1.start();            //再次创建Processor对象，每个线程拥有自己的对象            Runnable r2 = new Processor();            Thread t2 = new Thread(r2, "t2");            t2.start();        }       }    class Processor implements Runnable {        //定义成员变量s，作为累加变量            private int s = 0;        public void run() {            for (int i=0; i<10; i++) {                s+=i;            }               System.out.println(Thread.currentThread().getName() + ", s=" + s);            s = 0;        }    }

死锁

        synchronized(a){            ...//1             synchronized(b){           }        }        synchronized(b){            ... //2          synchronized(a){           }        }

解决死锁

• 一般我们借助于线程的通信解决死锁问题

       synchronized(a){        ...//1         wait();      synchronized(b){       }    }    synchronized(b){        ... //2      synchronized(a){            notify();       }    }

解决死锁的案例

线程状态

守护线程

• 从线程分类可以分为：

  • 用户线程(以上讲的都是用户线程)

  • 守护线程。守护线程是这样的，所有的用户线程结束生命周期，守护线程才会结束生命周期，只要有一个用户线程存在，那么守护线程就不会结束，例如java中著名的垃圾回收期就是一个守护线程，只有应用程序中所有的线程结束，它才会结束。

    public class DaemonThreadTest01 {    public static void main(String[] args) {        Runnable r1 = new Processor();        Thread t1 = new Thread(r1, "t1");        t1.start();        for (int i=0; i<10; i++) {            System.out.println(Thread.currentThread().getName() + ", " + i);        }        System.out.println("主线程结束！！！");    }   }class Processor implements Runnable {    public void run() {        for (int i=0; i<10; i++) {            System.out.println(Thread.currentThread().getName() + ", " + i);        }       }}

    主线程执行结束了，但用户线程仍然将数据打印出来了

守护（服务线程）线程示例

    public class DaemonThreadTest02 {        public static void main(String[] args) {            Runnable r1 = new Processor();            Thread t1 = new Thread(r1, "t1");            //将当前线程修改为守护线程，在线程没有启动时可以修改以下参数            t1.setDaemon(true);            t1.start();            for (int i=0; i<10; i++) {                System.out.println(Thread.currentThread().getName() + ", " + i);            }            System.out.println("主线程结束！！！");        }       }    class Processor implements Runnable {        public void run() {            for (int i=0; i<10; i++) {                System.out.println(Thread.currentThread().getName() + ", " + i);            }           }    }