浅析线程进程相关的知识点

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