继承Thread类

1.线程、进程

1.1 概念

进程：引入：为了程序能够并发执行，且为了对并发执行的程序加以描述和控制，引入了进程的概念。

　　（1）进程是程序的一次执行。

　　（2）进程是一个程序及其数据在处理机上顺序执行时所发生的活动。

　　（3）进程是程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位。

　　（4）进程是作为能够拥有资源和独立运行的基本单位。

线程:  引入：在操作系统中引入线程，是为了减少程序并发执行时锁付出的空间开销，使OS具有更好的并发性。1.2

1.2 线程与进程进行比较

　　线程具有许多传统进程所具有的特征，所以又称为轻量级进程或进程元，相应的把进程称为重量级的进程，传统进程相当于只有一个线程的任务，在引入了新城的操作系统中，通常一个进程都拥有若干个线程，至少也有一个线程。

　　相同点：

　　（1）调度：

　　（2）并发性：在引入了线程的操作系统中，进程之间或一个线程中的多个线程之间都可以并发执行。

　　（3）拥有资源：不论是传统的操作系统还是引入了线程的操作系统，进程都可以拥有资源，是系统中拥有资源的有个基本单位。

　　（4）系统开销：在某些操作系统中，线程的切换、同步和通信都无需操作系统内核的干预。

　　不同点：

　　（1）调度：在传统操作系统中，进程是拥有资源的基本和独立调度、分派的基本单位，在引入了线程的操作系统中，线程是调度和分派的基本单位，而进程是拥有资源的基本单位。

　　（2）并发性：

　　（3）拥有资源：进程拥有资源，线程自己不拥有资源（也有一点必不可少的资源）。但可以吧访问其他隶属进程的资源。

　　（4）系统开销：

　　　　a.在创建或撤销进程的时候，系统都要为之创建和回收进程控制块，分配或回收资源。如内存空间和I/O设备，系统开销明显大于线程创建或撤销时的开销。

　　　　b.在进程切换时，涉及到当前进程CPU环境的保存及新被调度运行进程的CPU环境的设置，而线程的切换则仅需要保存和设置少量寄存器内容，不涉及存储器管理方面的操作，所以，进程的代价远高于线程。

　　　　c.一个进程的多个线程具有相同的地址空间，在同步和通信的实现方面线程也比进程容易。

　　（5）进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

　　（6）进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮。

　　（7）每个独立的线程都有一个程序运行的入口，顺序执行序列和程序的入口，但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

1.3 线程的生命周期

1.3.1.线程处于就绪状态有以下几种方法

　　（1）调用sleep（）方法

　　（2）调用wait（）方法

　　（3）等待输入/输出完成

1.3.2.当线程处于就绪状态后，可以用以下几种方法使线程进入运行状态：

　　（1）线程调用notify（）方法

　　（2）线程调用notifyAll（）方法

　　（3）线程调用interrupt（）方法

　　（4） 线程的休眠时间结束

　　（5）输入/输出结束

　　线程生命周期状态图：

　　　　　　　　　　　　　　

2.线程的调度与控制

2.1 线程优先级

　　java虚拟机主要负责则线程的调度，获取CPU的使用权，目前有两种调度模型：分时调度模型和抢占调度模型;java使用抢占调度模型。

　　分时调度模型：所有线程轮流使用CPU的使用权，平均分配给每个线程占用CPU的时间片。

　　抢占调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么随机选择一个，优先极高的线程获得的CPU时间片相对多些。

例：

 /*
    线程优先级高的获取的时间片相对高
 */
 class  Threadtest04
 {
     public static void main(String[] args)
     {
         //线程优先级
         System.out.println(Thread.MAX_PRIORITY); //10 优先级最高
         System.out.println(Thread.MIN_PRIORITY); //1  优先级最低
         System.out.println(Thread.NORM_PRIORITY); //5  默认优先级
         Thread t1 = new P();
         t1.setName("t1");

         Thread t2 = new P();
         t2.setName("t2");

         System.out.println(t1.getPriority()); //默认优先级为5
         System.out.println(t2.getPriority()); //默认优先级为5
         //设置优先级
         t1.setPriority(4);
         t2.setPriority(9);

         System.out.println(t1.getPriority()); //默认优先级为5
         System.out.println(t2.getPriority()); //默认优先级为5
         //启动线程
         t1.start();
         t2.start();
     }
 }

 class P extends Thread
 {
     public void run()
     {
         for(int i=0;i<10;i++)
         {
             System.out.println(Thread.currentThread().getName()+"..."+i);
         }
     }
 }
 /*
 运行结果：
 10
 1
 5
 5
 5
 4
 9
 t1...0
 t2...0
 t1...1
 t2...1
 t1...2
 t2...2
 t1...3
 t2...3
 t1...4
 t2...4
 t1...5
 t2...5
 t1...6
 t2...6
 t1...7
 t2...7
 t1...8
 t2...8
 t1...9
 t2...9
 请按任意键继续. . .

 */

2.2 sleep方法

　　sleep和wait的区别：

（1）所属类不同

Thread.sleep() ；   Object.wait()

（2）对于线程已经占有资源的处理

sleep在休息的时候，不释放资源 ； wait在等待的时候释放自己占用的资源

　　例：

 /*
   1.thread.sleep（毫秒）
   2.sleep方法是一个静态方法
   3.该方法作用：阻塞当前线程，将CPU让给其他线程
 */
 class Threadtest05
 {
     public static void main(String[] args) throws InterruptedException
     {
         Thread t1 = new P();
         t1.setName("t1");
         t1.start();
         Thread.sleep(5000);
         //t1.interrupt();打断线程的睡眠
         for(int i = 0;i<10;i++)
         {
             System.out.println(Thread.currentThread().getName()+".."+i);
             Thread.sleep(500);//阻塞主线程0.5秒
         }
     }
 }

 class P extends Thread
 {
     //被重写的方法不能抛出异常，在run方法的声明为置上不能呢使用Throws，
     public void run()
     {
         for(int i = 0;i<10;i++)
         {

             try{
                 Thread.sleep(1000);//让当前线程阻塞1s
             }catch(InterruptedException e)
             {
                 e.printStackTrace();
             }
             System.out.println(Thread.currentThread().getName()+".."+i);
         }
     }
 }
 /*
   运行结果：
   main..0
 t1..0
 main..1
 t1..1
 main..2
 main..3
 main..4
 t1..2
 main..5
 t1..3
 main..6
 main..7
 t1..4
 main..8
 main..9
 t1..5
 t1..6
 t1..7
 t1..8
 t1..9
 请按任意键继续. . .

 */

2.3 yield方法

　　使用yield方法，与sleep方法类似，不能由用户指定暂停多长时间，并且yield方法只能让同优先级的线程由执行机会,让位时间不固定。静态方法。

2.4 Join方法

　　合并线程

3.创建线程的三种方法

　　Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用三种方式来创建线程，如下所示：

　　（1）继承Thread类创建线程

　　（2）实现Runnable接口创建线程

　　（3）使用Callable和Future创建线程

3.1.概念及特点

　　（1）.概念

　　进程：计算机运行的应用程序。（多进程作用：提高CPU的使用率，不提高速度）；

　　线程；一个进程中的执行场景，一个进程可以包多个线程。（多线程作用：提高应用程序的使用率，不提高速度）。

　　（2）.内存特点

　　进程和进程之间的内存是独立的；

　　线程和线程共享“堆内存的方法区内存”，栈内存是独立的，一个线程一个栈。

　　（3）.java程序的运行原理

　　Java命令启动Java虚拟机，启动JVM，等同于启动了一个应用程序，表示启动了一个进程，该进程会自动启动一个“主线程”，然后主线程去调用某个类的main方法，所 以main方法运行在主线程中。

3.2 线程的创建和启动

3.2.1 实现多线程的第一种方式

　　Thread类在包java.lang中，从这个类中实例化的对象代表线程，启动一个新线程需要建立Thread实例，Thread类中常用的两个构造方法如下：

　　（1）public Thread（String threadName）

　　（2）public Thread（）

　　其中第一个构造方法是创建一个名称为threadName的线程对象

　　创建一个新的线程的语法如下：

　public class ThreadTest extends Thread{}

　　完成线程真正功能的代码方法类run（）方法中，当一个类继承Thread类后，就可以在该类中覆盖run方法，将实现该线程功能的代码写入run（）方法中国，然后调用Thread类中的start（）方法执行线程，即调用run()方法.

　　Thread对象需要一个任务来执行，任务是指线程在启动时执行的工作，该工作的功能代码被写在run（）方法中。当执行一个线程程序时，就自动产生一个线程，主方法是在这个线程上运次的，当不再启动其他线程时，该程序就为单线程程序。

　　 以下是一个Thread类的实例：

/**
 * 类ThreadTest继承继承Thread雷诺方法创建线程
 * @author z
 *
 */
public class ThreadTest extends Thread {
   private int count = 10;
   public void run(){
       while(true){
           System.out.println(count+"");
           if(--count == 0){
               return;
           }
       }
   }
    public static void main(String[] args){
        new ThreadTest().start();

    }
 }

　　运行结果：10 9 8 7 6 5 4 3 2 1

　　分析：

　　在上例中，继承了Thread类，然后覆盖了run（）方法，通常在run（）方法中使用无限循环的形式，使得线程一直运行下去，所以要指定一跳出循环的条件，本例使用变量count递减为0的方法跳出循环条件。

　　在main()方发中，使线程执行需要调用Thread类中的start（）方法，start（）方法调用被覆盖的run（）方法，如果不调用start（）方法，线程永远不会启动，在主方法没有调用stsrt（）方法之前，Thread（）对象只是一个实例，而不是一个正真的线程。

再举一个例子：

　　第一步: 继承Java.lang.Thread

　　第二步；重写run方法

　　例：

 class  Threadtest01
 {
     public static void main(String[] args)   //main方法在主线程
     {
         //1.创建线程
         Thread t = new p();
         //2.启动线程
         t.start();      /*启动t线程，执行后，t线程瞬间结束，JVM再分配一个新的栈给t线程
                           run方法不需要手动调用，系统线程启动之后自动调用run方法。*/

        for(int i=0;i<100;i++)   //在主线程中运行
         {
            System.out.println("main....."+i);
         }
     }
 }
 /*
    在多线程中，main方法结束后只是主线程踪没有方法栈帧了，但
    其他线程中或者其他栈中还有栈帧，main方法结束，程序可能还在运行
 */

 //3.定义一个线程
 class p extends Thread
 {
     //重写run方法
     public void run ()
     {
          for(int i=0;i<100;i++)
         {
            System.out.println("run...."+i);
         }
     }
 }
 /*
 运行部分结果如下：
 main.....0
 main.....1
 main.....2
 run....0
 main.....3
 run....1
 main.....4
 run....2
 main.....5
 run....3
 main.....6
 run....4
 main.....7
 run....5
 main.....8
 run....6
 */

　　上述代码的图解如下：

3.3.2 实现多线程的第二种方式:

　　Runnable接口的说用是使线程不仅可以继承Thread类实现，还可以继承其他类(比如：JFrame)。

　　此接口具有两个构造方法:

　　(1)public Thread(Runnable r)

　　(2)public Thread(Runnable r,String name).

　　这两个构造方法的参数中都存在Runnable实例，使用构造方法就可以将Runnable实例与Thread实例相关联。

　　使用Runnable的步骤如下：

　　（1）建立Runnable对象

　　（2）使用参数为Runnable对象的构造方法创建Thread实例

　　（3）调用start（）方法。

　　例：在项目中创建SwingAndThread类，该类继承了JFrame类，实现图标移动的功能，其中使用了Swing与线程相结合的技术：

 import java.awt.*;
 import java.net.*;

 import javax.swing.*;

 public class SwingAndThread extends JFrame {
     /**
      *
      */
     private static final long serialVersionUID = 1L;
     private JLabel jl = new JLabel(); // 声明JLabel对象
     private static Thread t; // 声明线程对象
     private int count = 0; // 声明计数变量
     private Container container = getContentPane(); // 声明容器

     public SwingAndThread() {
         setBounds(300, 200, 250, 100); // 绝对定位窗体大小与位置
         container.setLayout(null); // 使窗体不使用任何布局管理器
         URL url = SwingAndThread.class.getResource("/1.gif"); // 获取图片的URL
         Icon icon = new ImageIcon(url); // 实例化一个Icon
         jl.setIcon(icon); // 将图标放置在标签中
          // 设置图片在标签的最左方
         jl.setHorizontalAlignment(SwingConstants.LEFT);
         jl.setBounds(10, 10, 200, 50); // 设置标签的位置与大小
         jl.setOpaque(true);
         t = new Thread(new Runnable() { // 定义匿名内部类，该类实现Runnable接口
                     public void run() { // 重写run()方法
                         while (count <= 200) { // 设置循环条件
                              // 将标签的横坐标用变量表示
                             jl.setBounds(count, 10, 200, 50);
                             try {
                                 Thread.sleep(1000); // 使线程休眠1000毫秒
                             } catch (Exception e) {
                                 e.printStackTrace();
                             }
                             count += 4; // 使横坐标每次增加4
                             if (count == 200) {
                                 // 当图标到达标签的最右边，使其回到标签最左边
                                 count = 10;
                             }
                         }
                     }
                 });
         t.start(); // 启动线程
         container.add(jl); // 将标签添加到容器中
         setVisible(true); // 使窗体可视
         // 设置窗体的关闭方式
         setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
     }

     public static void main(String[] args) {
         new SwingAndThread(); // 实例化一个SwingAndThread对象
     }
 }

　　运行结果：

　　

　　再举一个例子：

　　第一步：写一个实现类java,lang.Runnable;接口

　　第二步：实现run方法

　　例：

 package test;

 class Main
 {
     public static void main(String[] args)
     {
         //创建线程
         Thread t = new Thread(new p());
         //启动线程
         t.start();
         for(int i = 0;i<100;i++)
               System.out.println("mian..."+i);

     }
 }
 //优先，一个类实现接口之外保留了类的继承
 class p implements Runnable
 {
     public void run()
     {
         for(int i = 0;i<100;i++)
           System.out.println("run..."+i);
     }
 }
 /*
  * 部分运行结果：
  * run...8
 mian...10
 run...9
 mian...11
 run...10
 mian...12
 run...11
 mian...13
 run...12
  */

4.线程的同步（加锁）

4.1 基本概念及特点

（1）概念：

　　a.线程同步，是指某一个时刻，只允许一个线程访问共享资源，线程同步实际上是对对象加锁，如果对象中的方法都是同步方法，那么某一时刻只能执 行一个方法，采用线程同步解决以上问题;  为了数据安全，尽管应用程序的使用效率降低，但是为了数据安全，必须加入线程同步机制，线程同步机制使程序等同于单线程。

　　b.异步编程模型：多个线程分别执行，各线程互不影响。

　　c.同步编程模型：多个线程执行只有一个线程执行结束才能执行另一个线程。（作用：达到数据安全）

（2）使用线程同步机制的条件：

　　a：必须是多线程环境

　　b:多线程环境共享一个数据

　　c:共享的数据涉及到数据的修改

4.2 举例

　　例1：(对象锁，方法一，控制精确，常用)

 /*
    模拟银行取款系统：对于同一个账号，用两个线程同时对其取款。
 */
 class Threadtest06
 {
     public static void main(String[] args)
     {
        //创建公共账号
        Account act = new Account("账号sss",10000);
        //创建两个线程对同一个账户取款
        Thread t1 = new Thread(new P(act));
        Thread t2 = new Thread(new P(act));
        t1.start();
        t2.start();
     }
 }
 //取款线程
 class P implements Runnable
 {
     //账户
     Account act;
     P(Account act)
     {
         this.act = act;
     }
     public void run()
     {
         act.withdraw(2000);
         System.out.println("取款成功，余额为："+act.getBalance());
     }

 }
 //账户
 class Account
 {
     private String action;
     private double balance;
     public Account(){}
     public Account(String action,double balance){
       this.action = action;
       this.balance = balance;
     }
     public void setAction(String action)
     {
         this.action = action;
     }

     public void setBalance(double balance)
     {
         this.balance = balance;
     }
     public String getAction(String action)
     {
         return action;
     }
     public double getBalance()
     {
         return balance;
     }
     public void withdraw(double money)
     {
         synchronized(this){  //this表示共享对象
            double after = balance - money;
            try{
            Thread.sleep(1000);
            }catch(Exception e){}
            this.setBalance(after);
         }
     }
 }

 /*
 运行结果：
 取款成功，余额为：8000.0
 取款成功，余额为：6000.0
 请按任意键继续. . .

 */

　　上例原理：   t1线程执行到synchronized关键字处，就会去找this对象锁，如果找到this对象锁，就回进入同步语句块中执行，当同步语句块中的代码执行结束后，

　　t1线程归还this对象锁。在t1线程执行同步语句块的过程中，如果t2线程也过来执行此代码，也遇到synchronized关键字，所以也去找this对象锁，但是

　　该对象锁被t1线程持有，只能等待this对象的归还。

　　例2；synchronized关键字添加到成员方法上，线程拿到的扔是this的对象锁（对象锁，方法二，执行效率低）

 /*
    模拟银行取款系统：对于同一个账号，用两个线程同时对其取款。
 */
 class Threadtest06
 {
     public static void main(String[] args)
     {
        //创建公共账号
        Account act = new Account("账号sss",10000);
        //创建两个线程对同一个账户取款
        Thread t1 = new Thread(new P(act));
        Thread t2 = new Thread(new P(act));
        t1.start();
        t2.start();
     }
 }
 //取款线程
 class P implements Runnable
 {
     //账户
     Account act;
     P(Account act)
     {
         this.act = act;
     }
     public void run()
     {
         act.withdraw(2000);
         System.out.println("取款成功，余额为："+act.getBalance());
     }

 }
 //账户
 class Account
 {
     private String action;
     private double balance;
     public Account(){}
     public Account(String action,double balance){
       this.action = action;
       this.balance = balance;
     }
     public void setAction(String action)
     {
         this.action = action;
     }

     public void setBalance(double balance)
     {
         this.balance = balance;
     }
     public String getAction(String action)
     {
         return action;
     }
     public double getBalance()
     {
         return balance;
     }
     public  synchronized void withdraw(double money)
     {

            double after = balance - money;
            try{
            Thread.sleep(1000);
            }catch(Exception e){}
            this.setBalance(after);

     }
 }

 /*
 运行结果：
 取款成功，余额为：8000.0
 取款成功，余额为：6000.0
 请按任意键继续. . .

 */

　　（另：StirngBuffer  Vector Hashtable 是线程安全的 ）

5.死锁

　　例：

 /*
    死锁
 */
 class DeadLook
 {
     public static void main(String[] args)
     {
        Object o1 = new Object();
        Object o2 = new Object();

        Thread t1 = new Thread(new T1(o1,o2));
        Thread t2 = new Thread(new T2(o1,o2));
        t1.start();
        t2.start();
     }
 }

 class T1 implements Runnable
 {
     Object o1;
     Object o2;
     T1(Object o1,Object o2)
     {
         this.o1 = o1;
         this.o2 = o2;
     }
     public void run()
     {
         synchronized(o1)
         {
             try{Thread.sleep(1000);}catch(Exception e){}
             synchronized(o2)
             {
                 System.out.println("t1");
             }
         }
     }
 }
 class T2 implements Runnable
 {
     Object o1;
     Object o2;
     T2(Object o1,Object o2)
     {
         this.o1 = o1;
         this.o2 = o2;
     }
     public void run()
     {
         synchronized(o2)
         {
             try{Thread.sleep(1000);}catch(Exception e){}
             synchronized(o1)
             {
                 System.out.println("t2");
             }
         }
     }
 }

6.守护线程

　　从线程的分类上可以分为：用户线程和守护线程，所有的用户线程结束生命周期，只有一个用户线程存在，那么守护线程就不会结束，Java中的垃圾回收器就

　　是一个守护线程，只有应用程序中所有的线程结束，它才会结束。

　　例：

 /*
    守护线程：
    所有的用户线程结束，守护线程才会结束，守护线程是一个无限循环执行的。
 */
 class  Threadtest08
 {
     public static void main(String[] args) throws Exception
     {
         Thread t1 = new P();
         t1.setName("t1");
         t1.setDaemon(true);//将用户线程修改为守护线程
         t1.start();
         //主线程
         for(int i = 0;i < 10; i++)
         {
            System.out.println(Thread.currentThread().getName()+".."+i);
            Thread.sleep(1000);
         }
     }
 }

 class P extends Thread
 {
    public void run()
     {
        int i = 0;
        while(true)
         {
            i++;
            System.out.println(Thread.currentThread().getName()+".."+i);
            try{Thread.sleep(1000);}catch(Exception e){}
         }
     }
 }
 /*
 运行结果：
 main..0
 t1..1
 t1..2
 main..1
 t1..3
 main..2
 main..3
 t1..4
 main..4
 t1..5
 main..5
 t1..6
 main..6
 t1..7
 main..7
 t1..8
 main..8
 t1..9
 main..9
 t1..10
 请按任意键继续. . .

 */

7.Timer定时器

　　作用：每隔一段固定的时间执行一段代码

　　例：

 /*
    定时器
 */
 import java.text.*;
 import java.util.*;
 class  Timertest
 {
     public static void main(String[] args) throws Exception
     {
         //创建定时器
         Timer t = new Timer();
         //指定定时任务
         t.schedule(new LogTimerTask(),new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").parse("2017-04-21 11:42:00 000"),10*1000);

     }
 }
 //指定任务
 class LogTimerTask extends TimerTask
 {
     public void run()
     {
         System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date()));
     }
 }

8.线程池

   参考资料   http://www.importnew.com/19011.html

                    http://lavasoft.blog.51cto.com/62575/27069/

                    https://mp.weixin.qq.com/s?__biz=MzI1NDQ3MjQxNA==&mid=2247484346&idx=1&sn=f065ebd404771a90988bb097ea4e26dd&chksm=e9c5fa0bdeb2731d12b838372fc8aa97890dd2e3379d1a486df7cf795f8a1538c1ae974a13e7&mpshare=1&scene=23&srcid=1022Iecc2i96j9Drfxgzd274#rd