黑马程序员线程

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

黑马程序员线程

Java中如果我们自己没有产生线程，那么系统就会给我们产生一个线程（主线程，main方法就在主线程上运行），我们的程序都是由线程来执行的。进程：执行中的程序（程序是静态的概念，进程动态的概念）。

当程序启动运行时，就自动产生一个线程，主方法main就在这个主线程上运行。一个进程可以包含一个或多个线程。如果程序要实现多个代码同时交替运行，就需要产生多个线程。CPU随机的抽出时间，让我们的程序一会做这件事情，一会做另外一件事情，所以线程执行顺序是随机的，不确定的。

线程有四个：

1.       创建状态。当用new操作符创建一个新的线程对象时，该线程处于创建状态。

2.       可运行状态（就绪状态）。执行线程的start()方法为线程分配必需的系统资源，安排其运行，调用线程体run()方法，这样就使得该线程处于可运行状态。

3.       阻塞状态。当发生下列事件时，处于运作状态的线程转入阻塞状态。（1）调用sleep()方法。（2）线程调用wait()方法等待特定条件的满足（3）线程输入/输出阻塞。

4.       消亡状态。当线程的run方法执行结束后，该线程自然消亡。

对于单核CPU来说，某一时刻只能有一个线程在执行（微观串行），从宏观角度来看，多个线程在同时执行（宏观并行）。对于双核或双核以上的CPU来说，可以真正做到微观并行。

Thread类也实现了Runnable接口，因此实现了Runnable接口中的run方法；当生成一个线程对象时，如果没有为其设定名字，那么线程对象的名字将使用如下形式：Thread-number，该number将是自动增加的，并被所有的Thread对象所共享（因为它是static的成员变量）。

线程的实现有两种方式，第一种方式是继承Thread类，然后重写run方法；第二种是实现Runnable接口，然后实现其run方法。将我们希望线程执行的代码放到run方法中，然后通过start方法来启动线程，start方法首先为线程的执行准备好系统资源，然后再去调用run方法。当某个类继承了Thread类之后，该类就叫做一个线程类。一个线程至少要包含一个线程。

当使用第一种方式来生成线程对象时，我们需要重写run方法，因为Thread类的run方法此时什么事情也不做。当使用第二种方式来生成线程对象时，我们需要实现Runnable接口的run方法，然后使用new Thread(new MyThread())（假如MyThread已经实现了Runnable接口）来生成线程对象，这时的线程对象的run方法就会调用MyThread类的run方法，这样我们自己编写的run方法就执行了。

关于成员变量与局部变量：如果一个变量是成员变量，那么多个线程对同一个对象的成员变量进行操作时，他们对该成员变量是彼此影响的（也就是说一个线程对成员变量的改变会影响到另一个线程）。

如果一个变量是局部变量，那么每个线程都会有一个该局部变量的拷贝，一个线程对该局部变量的改变不会影响到其他的线程。

停止线程的方式：不能使用Thread类的stop方法来终止线程的执行。一般要设定一个变量，在run方法中是一个循环，循环每次检查该变量，如果满足条件则继续执行，否则跳出循环，线程接受。

可以通过setPriority(int num)来设置线程的优先级。

synchronized关键字：当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。

Java中的每个对象都有一个锁或者叫做监视器，当访问某个对象的synchronized方法时，表示将该对象上锁，此时其他任何线程都无法再去访问该synchronized方法了，直到之前的那个线程执行方法完毕后（或者是抛出了异常），那么将该对象的锁释放掉，其他线程才有可能再去访问该synchronized方法。

如果一个对象有多个synchronized方法，某一时刻某个线程已经进入到了某个synchronized方法，那么在该方法没有执行完毕前，其他线程是无法访问该对象的任何synchronized方法的。

如果某个synchronized方法时static的，那么当线程访问该方法时，它锁的并不是synchronized方法所在的对象，而是synchronized方法所在的对象所对应的Class对象，因为java中无论一个类有多少个对象，这些对象会对应唯一一个Class对象，因此当线程分别访问同一个类的两个对象的两个static，synchronized方法时，他们的执行顺序也是顺序的，也就是说一个线程先去执行方法，执行完毕后另一个线程才开始执行。

Synchronized块，写法：

Synchronized(object)

{

}

表示线程在执行的时候会对object对象上锁。

Synchronized方法是一种粗粒度的并发控制，某一时刻，只能有一个线程执行该synchronized方法；synchronized块则是一种细粒度的并发控制，只会将块中的代码同步，位于方法内、synchronized块之外的代码是可以被多个线程同时访问到的。

wait与notify方法都是定义在Object类中，而且是final的，因此会被所有的java类所继承并且无法重写。这两个方法要求在调用时线程应该已经获得了对象的锁，因此对这两个方法的调用需要放在synchronized方法或块当中。当线程执行了wait方法时，它会释放掉对象的锁。

线程间通信：等待/唤醒机制，也就是常见的生产者消费者问题。需要注意的是：

1.当多个生产者消费者出现时，需要让获取执行权的线程判断标记。通过while完成。

2.需要将对方的线程唤醒。仅仅用notify，是不可以的。因为有可能出现只唤醒本方。有可能会导致，所有线程都等待。所以可以通过notifyAll的形式来完成 。

另一个会导致线程暂停的方法是Thread类的sleep方法，它会导致线程睡眠指定的毫秒数，但线程在睡眠的一个过程中是不会释放掉对象的锁的。Wait()方法会释放锁。

线程组：所有线程都属于一个线程组。那可以是一个默认线程组，也可以是一个创建线程时明确指定的组。说明：在创建之初，线程被限制在一个组里，而且不能改变到一个不同的组。若创建多个线程而不指定一个组，它们就会与创建它的线程属于同一个组。

Timer和TimerTask提供了提前安排将来某时间要执行任务的能力。使用这些类可以创建一个工作于后台的线程，该线程等待一段指定的时间。当指定的时间到来时，与该线程相连的任务被执行。不同的选项允许安排一个任务重复执行，或安排一个任务在指定的时间运行。Timer和TimerTask一起工作。Timer是一个用于安排一个将来执行的任务的类。被安排的任务必须是TimerTask的一个实例。因此，为了安排一个任务，首先应该创建一个TimerTask对象，然后使用Timer的一个实例安排执行它。

实例代码如下

package com.itheima;

publicclassThreadTest1

{

    publicstaticvoid main(String[] args)

    {

       Thread1 t1 = new Thread1("first thread");

       Thread1 t2 = new Thread1("second thread");

      

       System.out.println(t1.getName());

       System.out.println(t2.getName());

      

       t1.start();

       t2.start();

    }

}

 

class Thread1extends Thread

{

    public Thread1(String name)

    {

       super(name);

    }

   

    @Override

    publicvoid run()

    {

       for(int i = 0; i < 100; i++)

       {

           System.out.println("hello world: " + i);

       }

    }

}

 

class Thread2extends Thread

{

    public Thread2(String name)

    {

       super(name);

    }

   

    @Override

    publicvoid run()

    {

       for(int i = 0; i < 100; i++)

       {

           System.out.println("welcome: " + i);

       }

    }

}

 

 

package com.itheima;

publicclassThreadTest2

{

    publicstaticvoid main(String[] args)

    {

       Runnable r = new HelloThread();

      

       Thread t1 = new Thread(r);

      

       //r = new HelloThread();

      

       Thread t2 = new Thread(r);

      

       t1.start();

       t2.start();

    }

}

 

class HelloThreadimplements Runnable

{

    inti;

    @Override

    publicvoid run()

    {

       inti = 0;

      

       while(true)

       {

           System.out.println("number: " +this.i++);

          

           try

           {

              Thread.sleep((long)(Math.random() * 1000));

           }

           catch (InterruptedException e)

           {

              e.printStackTrace();

           }

          

           if(50 ==this.i)

           {

              break;

           }

       }

    }

}

 

 

package com.itheima;

publicclassThreadTest3

{

    publicstaticvoid main(String[] args)

    {

       Example example = new Example();

      

       Thread t1 = new TheThread(example);

      

       example = new Example();

      

       Thread t2 = new TheThread2(example);

      

       t1.start();

       t2.start();

    }

}

 

class Example

{

    publicsynchronizedstaticvoid execute()

    {

       for(int i = 0; i < 20; i++)

       {

           try

           {

              Thread.sleep((long)(Math.random() * 1000));

           }

           catch (InterruptedException e)

           {

              e.printStackTrace();

           }

          

           System.out.println("hello: " + i);

       }

    }

   

    publicsynchronizedstaticvoid execute2()

    {

       for(int i = 0; i < 20; i++)

       {

           try

           {

              Thread.sleep((long)(Math.random() * 1000));

           }

           catch (InterruptedException e)

           {

              e.printStackTrace();

           }

          

           System.out.println("world: " + i);

       }

    }

}

 

 

class TheThreadextends Thread

{

    private Exampleexample;

   

    public TheThread(Example example)

    {  

       this.example = example;

    }

   

    @Override

    publicvoid run()

    {

       this.example.execute();

    }

}

 

class TheThread2extends Thread

{

    private Exampleexample;

   

    public TheThread2(Example example)

    {  

       this.example = example;

    }

   

    @Override

    publicvoid run()

    {

       this.example.execute2();

    }

}

 

 

package com.itheima;

publicclassThreadTest4

{

    publicstaticvoid main(String[] args)

    {

       Example2 e = new Example2();

 

       TheThread3 t1 = new TheThread3(e);

      

       e = new Example2();

      

       TheThread4 t2 = new TheThread4(e);

 

       t1.start();

       t2.start();

    }

}

 

class Example2

{

    private Objectobject =new Object();

 

    publicvoid execute()

    {

       synchronized (this)

       {

           for (int i = 0; i < 20; i++)

           {

              try

              {

                  Thread.sleep((long) (Math.random() * 1000));

              }

              catch (InterruptedException e)

              {

                  e.printStackTrace();

              }

 

              System.out.println("hello: " + i);

           }

       }

 

    }

 

    publicvoid execute2()

    {

       synchronized(this)

       {

           for (int i = 0; i < 20; i++)

           {

              try

              {

                  Thread.sleep((long) (Math.random() * 1000));

              }

              catch (InterruptedException e)

              {

                  e.printStackTrace();

              }

 

              System.out.println("world: " + i);

           }

       }

      

      

    }

}

 

class TheThread3extends Thread

{

    private Example2example;

 

    public TheThread3(Example2 example)

    {

       this.example = example;

    }

 

    @Override

    publicvoid run()

    {

       this.example.execute();

    }

}

 

class TheThread4extends Thread

{

    private Example2example;

 

    public TheThread4(Example2 example)

    {

       this.example = example;

    }

 

    @Override

    publicvoid run()

    {

       this.example.execute2();

    }

}