Java基础_学习笔记_16_线程

1、进程与线程

进程，在多任务操作系统中，每个独立执行的程序称为进程，也就是“正在进行的程序”。进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配的最小单元。

线程，是进程中的一部分，是一个程序内部的一条执行线索。在网络或多用户环境下，一个服务器需要接受大量且不确定用户数量的并发请求，为每一个请求创建一个进程显然是行不通的，因此引入了线程。线程是最小的调度单元。通常在一程序中实现多段代码同时交替运行时，需要产生多个线程，并制定每个线程上所要运行的程序代码块，这就是多线程。

进程是操作系统资源分配的单位,而线程是操作系统执行的单位。

进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。（转）

当程序启动运行时，就自动产生了一个线程，主函数main就是在这个线程上运行的，当不再产生新的线程时，程序就是单线程的。

public class ThreadDemo
{
    public static void main(String [] args)
    {
        new TestThread().run();//代码1
        while(true)
        {
            System.out.println("main Thread is running~");//代码2
        }
    }
}
class TestThread
{
    public void run()
    {
        while(true)
        {
            System.out.println(Thread.currentThread().getName()+" is running");
            //currentTread()返回正在执行的线程对象
            //getName()是返回当前线程对象的名字
        }
    }    
}

上述代码中，没有创建新的线程，只是打印出当前线程。并且，线程运行是线性的，只有当执行完代码1之后，才会运行代码2，但由于1中是无限循环，所以总是打印出“main is running”

2、创建多线程的方法

1）继承Thread类

public class ThreadDemo
{
    public static void main(String [] args)
    {
        new TestThread().start();//.run();//代码1
        //调用新建线程启动
        while(true)
        {
            System.out.println("main Thread is running~");//代码2
        }
    }
}
class TestThread extends Thread//继承Thread类新建线程
{
    public void run()
    {
        while(true)
        {
            System.out.println(Thread.currentThread().getName()+" is running");
            //currentTread()返回正在执行的线程对象
            //getName()是返回当前线程对象的名字
        }
    }    
}

通过继承Thread类创建线程，并在main函数中调用start将该线程启动，也就是说现在有两个线程，所以交替打印出来两条语句，但是两个线程所执行的时间不相同。上面两段代码，也体现了单线程和多线程的区别。

要将一段代码在一个新的线程上运行，该代码需要放在Thread子类的run()中。也就是说，通过这种方式创建新线程，需要编写Thread的子类，并覆盖Thread类中的run();

启动一个新的线程，不是直接调用Thread子类中的run()，而是调用Thread子类对象的start方法。它会产生一个新的线程，并在该线程上运行该Thread类对象中的run()，根据多态性，其实也就是运行Thread子类对象中的run()。

可以不重写子类中的run么？不行，Thread中的run是空的，如果不重写run，根本就不知道创建的这个线程是用来执行什么的；为什么需要编写一个类来继承Thread类，我可以直接new Thread().start()么?不行，这样操作之后，它是调用Thread中的run,同上，创建了一个空的线程。这两种情况打印出来的结果都是一样的，只显示“main Thread is running~”

2）实现Runnable接口

public class ThreadDemo
{
    public static void main(String [] args)
    {
        //new TestThread().start();
        //TestThread是实现了Runnable接口，Runnable中没有start方法
        //调用新建线程启动
        Thread tt=new Thread(new TestThread());
        tt.start();
        while(true)
        {
            System.out.println("main Thread is running~");
        }
    }
}
class TestThread implements Runnable//extends Thread//继承Thread类新建线程
{
    public void run()//线程的代码段，当执行start时，线程从此处开始执行
    {
        while(true)
        {
            System.out.println(Thread.currentThread().getName()+" is running");
            //currentTread()返回正在执行的线程对象
            //getName()是返回当前线程对象的名字
        }
    }    
}

Runnable接口中只有一个run方法，所以当我们用TestThread类来实现Runnable时，不能直接创建TestThread的匿名对象调用start方法，只有Thread类中才有start()。那如何才能启动线程呢？我们可以通过public Thread(Runnable target)构造函数来实现，从而来调用start()。

3、比较上述两种创建方式

前提：现在要实现一个多线程售票的功能

public class ThreadDemo
{
    public static void main(String [] args)
    {
        TestThread t=new TestThread();
        t.start();
        t.start();
        t.start();
        t.start();
    }
}
class TestThread extends Thread//继承Thread类新建线程
{
    private int tickets=100;
    public void run()//线程的代码段，当执行start时，线程从此处开始执行
    {
        while(tickets>0)
        {
            System.out.println(Thread.currentThread().getName()+" the saling ticket number is "+tickets);
            tickets--;
        }
    }    
}

结果是一个线程t完成所有的工作，而不是像我们预想的那样是有四个线程来并发执行。也就是说，一个线程对象只能启动一个线程，无论调用多少遍start，都只有那一个线程。

将上述代码改动一下：

public class ThreadDemo
{
    public static void main(String [] args)
    {
        new TestThread().start();
        new TestThread().start();
        new TestThread().start();
        new TestThread().start();
    }
}
class TestThread extends Thread//继承Thread类新建线程
{
    private int tickets=100;
    public void run()//线程的代码段，当执行start时，线程从此处开始执行
    {
        while(tickets>0)
        {
            System.out.println(Thread.currentThread().getName()+" the saling ticket number is "+tickets);
            tickets--;
        }
    }    
}

创建四个线程对象来执行，但是，结果显示，每一个对象都有售出1-100的票。也就是说，这四个线程是独立的，每个对象都要处理100张票。但我们需要的是这四个线程共同来卖出这100张票，那就只能有一个对象。

从这两段代码我们可以知道，如果我们只创建一个线程对象，那只有一个线程来卖100张票；如果我们创建多个线程，那也无法实现，多线程卖票的功能。

我们改用实现Runnable接口

public class ThreadDemo
{
    public static void main(String [] args)
    {
        TestThread t=new TestThread();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
    }
}
class TestThread implements Runnable
{
    private int tickets=100;
    public void run()//线程的代码段，当执行start时，线程从此处开始执行
    {
        while(tickets>0)
        {
            System.out.println(Thread.currentThread().getName()+" the saling ticket number is "+tickets);
            tickets--;
        }
    }    
}

这样只有一个TestThread对象t对应那100张票，并且有四个线程交替执行。这样就可以满足我们当初的设想了。

从上面的例子我们可以看出，Runnable接口相对于继承Thread类的优点：

1）适合同一代码中多个线程处理同一资源的情况；

2）可以避免由于Java的单继承性带来的局限；

3）有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自于同一个类的实例时，即称它们共享相同的代码。多个线程可以操作相同的数据，与它们的代码无关。

实际工作中，几乎所有的多线程应用都采用实现Runnable接口的方式。

4、多线程的同步

4.1 线程安全

按照我们编写的代码，在实际售票过程中，可能会出现这样的问题。当某线程正在卖最后一张票，刚比较完ticket>0，此时，CPU切换到另一个线程执行，当它把最后一张票卖完之后，打印出正在卖tickets=1的票，再切回来，此时不用再比较ticket是否大于零（之前已经比较过），那么tickets=1会被再次打印出来。我们可以通过Thread.sleep()进行模拟。

public static void sleep(long millis)

　　throws InterruptedException

由于Thread.sleep()的定义中通过throws关键字声明该方法中有可能引发异常，所以，我们的程序在调用该方法时，必须使用try...catch代码块处理。

public class ThreadDemo
{
    public static void main(String [] args)
    {
        TestThread t=new TestThread();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
    }
}
class TestThread implements Runnable
{
    private int tickets=100;
    public void run()//线程的代码段，当执行start时，线程从此处开始执行
    {
        while(tickets>0)
        {
            try{
                Thread.sleep(10);
            }
            catch(Exception e)
            {
                System.out.println(e.getMessage());
            }
            System.out.println(Thread.currentThread().getName()+" the saling ticket number is "+tickets);
            tickets--;
        }
    }    
}
/*
......
Thread-2 the saling ticket number is 10
Thread-1 the saling ticket number is 10
Thread-0 the saling ticket number is 8
Thread-3 the saling ticket number is 8
Thread-1 the saling ticket number is 6
Thread-2 the saling ticket number is 6
Thread-0 the saling ticket number is 4
Thread-3 the saling ticket number is 4
Thread-2 the saling ticket number is 2
Thread-1 the saling ticket number is 2
Thread-3 the saling ticket number is 0
Thread-0 the saling ticket number is 0
Thread-2 the saling ticket number is -2
*/

打印出来的部分结果显示，出现了刚才我们预料的那种错误，这就是线程安全的问题。

4.2 同步代码块

既然存在线程安全的问题，那我们要采取何种措施避免该类问题发生？我们希望当一个进程开始了，能够把代码执行完，再调用下一个进程，这样就保证了，不管什么时候，有且只有一个进程在执行这段代码。那就要引入synchronized。

public class ThreadDemo
{
    public static void main(String [] args)
    {
        TestThread t=new TestThread();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
    }
}
class TestThread implements Runnable
{
    private int tickets=100;
    String str=new String("");
    public void run()//线程的代码段，当执行start时，线程从此处开始执行
    {
        while(true)
        {
            synchronized(str)
            {
                if(tickets>0)
                {
                    try{
                    Thread.sleep(10);
                    }
                catch(Exception e)
                {
                    System.out.println(e.getMessage());
                }            
                System.out.println(Thread.currentThread().getName()+" the saling ticket number is "+tickets);
                tickets--;
                }
                
            }
        }
    }    
}

上述代码中，我们将具有原子性的代码放入synchronized语句内，形成了同步代码块。在同一时刻只有一个线程可以进入同步代码块内运行，只有当该线程离开同步代码块后，其他线程才能进入同步代码块内运行。synchronized语句格式为:

synchronized(object){代码段}；//object可以是任意对象

所以我们创建了一个str对象，作为其参数。

synchronized的原理是，任意对象都有一个标志位，且只有“0”、“1”两种状态，初始值为“1”，当执行synchronized(object)语句后，对象的标志位为“0”，直到执行完整个synchronized代码块后又回到1状态。当一个线程执行到synchronized语句时，会去校验对象的标志位，为1则该进程可以去执行，为0则该进程需要暂时阻塞，让出CPU资源，直至那个正在执行的线程执行完同步代码块。标志位专业术语是锁旗标，用于synchronized语句中的对象，称为监视器。当一个线程获得了synchronized语句中的代码块执行权，即意味着它锁定了一个监视器。

实现同步，需要进行多次校验，所以是以牺牲程序的性能为代价的，如果我们能够确定程序没有安全性的问题，就没有必要使用同步控制。

如果将String str=new String("");放入run()内部，会出现什么结果？每个进程都会有一个str对象，就无法实现原子性了，无法同步。

4.3 同步函数

使用同步函数，同样也能实现多线程同步

public class ThreadDemo
{
    public static void main(String [] args)
    {
        TestThread t=new TestThread();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
    }
}
class TestThread implements Runnable
{
    private int tickets=100;
    //String str=new String("");
    public void run()//线程的代码段，当执行start时，线程从此处开始执行
    {
        String str=new String("");
        while(true)
        {
            
            sale();
            /*synchronized(str)
            {
                if(tickets>0)
                {
                    try{
                    Thread.sleep(10);
                    }
                catch(Exception e)
                {
                    System.out.println(e.getMessage());
                }            
                System.out.println(Thread.currentThread().getName()+" the saling ticket number is "+tickets);
                tickets--;
                }
                
            }*/
        }
    }    

    public synchronized void sale()
    {
        if(tickets>0)
        {
        try{
            Thread.sleep(10);
            }
        catch(Exception e)
        {
            System.out.println(e.getMessage());
        }            
        System.out.println(Thread.currentThread().getName()+" the saling ticket number is "+tickets);
        tickets--;
        }    
    }
}

4.4 代码块与函数之间的同步

同步代码块、同步函数其实采用的都是synchronized关键字，只要塔门采用同一个对象进行监视，两者之间是可以同步的，此处就不再验证。

当多个线程共享数据时，必须防止一个线程对共享数据仅仅进行部分操作就退出的情况出现，在这种情况下会破坏数据的一致性。如果要使线程1、2同步，线程3、4同步，那就必须要有两个对象，线程1、2由一个对象来控制，线程3、4的同步由另一个对象来控制，且这两个对象之间没有任何关系。

4.5 死锁

因为线程可以阻塞，并且具有同步控制机制可以防止其他线程在锁还没有释放的情况下访问这个对象，就容易产生矛盾。比如，A线程等待B线程，而B线程又在等待线程A，这样就造成了死锁。

一般造成死锁必须同时满足如下四个条件：

1）互斥条件

县城使用的资源至少有一个是不能共享的。

2）请求与保持条件

至少有一个线程必须持有一个资源并且正在等待获取一个当前被其他线程持有的资源。

3）非剥夺条件

分配的资源不能从相应的线程中被强制剥夺。

4）循环等待条件

第一个线程等待其他线程，后者又在等待第一个线程。

要发生死锁，这四个条件必须同时满足。反之，要防止死锁，只需要破坏其中一个条件即可。

5、线程之间的通信

现在要实现一个生产者、消费者的模式，生产者放一个消息，缓冲区中有消息了则不再放，消费者就取走一个消息，缓冲区中没有消息则不再取。

class Producer implements Runnable
{
    Q q;
    public Producer(Q q)
    {
        this.q=q;
    }
    public void run()
    {
        int i=0;
        while(true)
        {
            if(i==0)
            {
                q.name="Jane";
                try{Thread.sleep(1);}catch(Exception e){System.out.println(e.getMessage());}
                q.sex="female";
            }
            else
            {
                q.name="Mike";
                q.sex="male";
            }
            i=(i+1)%2;
        }
    }
}
class Consumer implements Runnable
{
    Q q;
    public Consumer(Q q)
    {
        this.q=q;
    }
    public void run()
    {
        while(true)
        {
            System.out.print(q.name);
            System.out.println(" "+q.sex);
        }
        
    }
}
class Q
{
    String name;
    String sex;
}
public class ThreadCommunication
{
    public static void main(String [] args)
    {
        Q q=new Q();
        new Thread(new Producer(q)).start();
        new Thread(new Consumer(q)).start();
    }
}

Q即为缓冲区，这是一个雏形，运行之后，发现，Jane居然对应的性别是male。也就是说可能是这种情况，缓冲区之前存的是Mike,male，这一次当线程刚把Jane写进去，时间片就用完了，转到下一个消费者线程去取缓冲区数据，所以打印出来是Jane,female。

也就是说，存在一个原子性的问题，操作还没有进行完，线程就进行了切换，需要加上synchronized。

class Producer implements Runnable
{
    Q q;
    public Producer(Q q)
    {
        this.q=q;
    }
    public void run()
    {
        int i=0;
        while(true)
        {
            synchronized(q)
            {
                if(i==0)
                {
                    q.name="Jane";
                    try{Thread.sleep(1);}catch(Exception e){System.out.println(e.getMessage());}
                    q.sex="female";
                }
                else
                {
                    q.name="Mike";
                    q.sex="male";
                }
                i=(i+1)%2;
            }

        }
    }
}
class Consumer implements Runnable
{
    Q q;
    public Consumer(Q q)
    {
        this.q=q;
    }
    public void run()
    {
        while(true)
        {
            synchronized(q)
            {
                System.out.print(q.name);
                System.out.println(" "+q.sex);
            }
        }
        
    }
}
class Q
{
    String name;
    String sex;
}
public class ThreadCommunication
{
    public static void main(String [] args)
    {
        Q q=new Q();
        new Thread(new Producer(q)).start();
        new Thread(new Consumer(q)).start();
    }
}

加上同步代码块之后，运行发现还是没有达到最初的设想，从缓冲区了取了多次，而不是放、取交替进行。那么就要实现，当放入数据后，等待消费者来取，取走数据了，生产者再来放入数据；当生产者没有放入数据时，消费者需要等，回到有数据可以取。那就涉及到让线程等待和唤起的操作。

java中通过Object类的wait、notify、notifyAll这些方法来实现线程间的通信：

wait：告诉当前线程放弃监视器并进入睡眠状态，直到其他线程进入同一监视器并调用notify为止

notify：唤醒同一对象监视器中调用wait的第一个线程。

notifyAll：唤醒同一对象监视器中调用wait的所有进程，有最高优先级的线程首先被唤醒并执行

现在我们知道了可以采用wait、notify来休眠和唤醒线程，但是什么情况下，需要线程休眠或者是唤醒呢？当缓冲区中没数据的时候，消费者线程就需要wait，缓冲区中有数据的时候，生产者线程需要wait。那么我们需要用一个变量来标识缓冲区中是否有数据，如程序中的bFull，false表示缓冲区为空

class Producer implements Runnable
{
    Q q;
    public Producer(Q q)
    {
        this.q=q;
    }
    public void run()
    {
        int i=0;
        while(true)
        {
            synchronized(q)
            {
                if(q.bFull)//缓冲区不为空，需要等值被取走之后再放入，以免覆盖之前的值
                    try{q.wait();}catch(Exception e){System.out.println(e.getMessage());}
                if(i==0)
                {
                    q.name="Jane";
                    try{Thread.sleep(1);}catch(Exception e){System.out.println(e.getMessage());}
                    q.sex="female";
                }
                else
                {
                    q.name="Mike";
                    q.sex="male";
                }
                i=(i+1)%2;
                q.bFull=true;//放值之后，缓冲区不为空
                q.notify();
            }

        }
    }
}
class Consumer implements Runnable
{
    Q q;
    public Consumer(Q q)
    {
        this.q=q;
    }
    public void run()
    {
        while(true)
        {
            synchronized(q)
            {
                if(!q.bFull)//缓冲区Q中是空的,需要等放值之后再来输出
                    try{q.wait();}catch(Exception e){System.out.println(e.getMessage());}
                    //让出监视器
                System.out.print(q.name);
                System.out.println(" "+q.sex);
                q.bFull=false;//取值之后，缓冲区为空
                q.notify();
            }
        }
        
    }
}
class Q
{
    String name;
    String sex;
    boolean bFull=false;//标识缓冲区中内容是否为空，false表示为空
}
public class ThreadCommunication
{
    public static void main(String [] args)
    {
        Q q=new Q();
        new Thread(new Producer(q)).start();
        new Thread(new Consumer(q)).start();
    }
}

有两个地方需要注意：

bFull是Q类中的成员，需要使用对象来引用；

wait、notify、notifyAll这三个方法只能在synchronized方法中使用，即无论线程调用一个对象的wait还是notify方法，该线程必须要先得到该对象的锁旗标，这样，notify只能唤醒同一个对象监视器中调用wait的线程，使用多个对象监视器，我们就可以分组有多个wait、notify的情况。所以需要使用对象引用wait和notify

将上述完整代码再做一下整合，更好地体现面向对象的思想

class Producer implements Runnable
{
    Q q;
    public Producer(Q q)
    {
        this.q=q;
    }
    public void run()
    {
        int i=0;
        while(true)
        {
            /*synchronized(q)
            {
                if(q.bFull)//缓冲区不为空，需要等值被取走之后再放入，以免覆盖之前的值
                    try{q.wait();}catch(Exception e){System.out.println(e.getMessage());}
                if(i==0)
                {
                    q.name="Jane";
                    try{Thread.sleep(1);}catch(Exception e){System.out.println(e.getMessage());}
                    q.sex="female";
                }
                else
                {
                    q.name="Mike";
                    q.sex="male";
                }
                i=(i+1)%2;
                q.bFull=true;//放值之后，缓冲区不为空
                q.notify();
            }*/
            if(i==0)
                q.put("Jane","female");
            else
                q.put("Mike","male");
            i=(i+1)%2;

        }
    }
}
class Consumer implements Runnable
{
    Q q;
    public Consumer(Q q)
    {
        this.q=q;
    }
    public void run()
    {
        while(true)
        {
            /*synchronized(q)
            {
                if(!q.bFull)//缓冲区Q中是空的,需要等放值之后再来输出
                    try{q.wait();}catch(Exception e){System.out.println(e.getMessage());}
                    //让出监视器
                System.out.print(q.name);
                System.out.println(" "+q.sex);
                q.bFull=false;//取值之后，缓冲区为空
                q.notify();
            }*/
            q.get();
        }
        
    }
}
class Q
{
    private String name;
    private String sex;
    private boolean bFull=false;//标识缓冲区中内容是否为空，false表示为空
    public synchronized void put(String name,String sex)
    {
        if(bFull)//缓冲区不为空，需要等值被取走之后再放入，以免覆盖之前的值
            try{wait();}catch(Exception e){System.out.println(e.getMessage());}
        this.name=name;
        try{Thread.sleep(1);}catch(Exception e){System.out.println(e.getMessage());}
        this.sex=sex;
        bFull=true;//放值之后，缓冲区不为空
        notify();
    }
    public synchronized void get()
    {
        if(!bFull)//缓冲区Q中是空的,需要等放值之后再来输出
            try{wait();}catch(Exception e){System.out.println(e.getMessage());}
            //让出监视器
        System.out.print(name);
        System.out.println(" "+sex);
        bFull=false;//取值之后，缓冲区为空
        notify();
    }
    
}
public class ThreadCommunication
{
    public static void main(String [] args)
    {
        Q q=new Q();
        new Thread(new Producer(q)).start();
        new Thread(new Consumer(q)).start();
    }
}

6、线程的生命周期

1）当调用start后，线程不是立马被调用，而是标识为Runnable状态，等到调度器将CPU分配给它；

2）当线程在执行过程中，没有遇到任何阻碍，运行完成直接结束，也就是run方法执行完毕；

3）请求锁旗标却一直得不到，这时候它要等待对象的锁旗标，得到锁旗标后才能进入Runnable状态

4）遇到wait方法，它会被放入等待池中继续等待，直到有notify或interrupt方法执行，他才会被唤醒或者打断开始等待对象锁旗标，等到锁旗标后进入Runnable状态继续执行

注意：Thread.interrupt()不会中断一个正在运行的线程。这一方法实际上完成的是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞的状态。更确切的说，如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞，那么，它将接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态。 

7、如何控制线程的生命

控制线程的生命周期有很多方法，如：suspend（将线程挂起），resume（将挂起的线程恢复，与suspend成对使用），stop。但这三个方法都停用了，不使用suspend，resume是因为：

1）会导致死锁的发生；

2）它允许一个线程A通过直接控制另外一个线程B的代码来控制线程B

stop虽然不会导致死锁，但是如果一个线程正在操作共享数据段，操作过程没有完成就stop的话，将会导致数据的不完整性。

那我们不用stop，怎么让一个线程停止运行？我们知道，当run方法结束，我们的线程就停止运行。

class ThreadLife
{
    public static void main(String [] args)
    {
        ThreadTest t=new ThreadTest();
        new Thread(t).start();
        for(int i=0;i<100;i++)
        {
            if(i==50)
                t.stopMe();
            System.out.println("mainThread is running "+i);
        }
    }
}
class ThreadTest implements Runnable
{
    private boolean bFlag=false;
    public void stopMe()
    {
        bFlag=true;
    }
    public void run()
    {
        while(!bFlag)
        {
            System.out.println(Thread.currentThread().getName()+" is running~");
        }
    }
}

上述代码中，采用了一个标志，当bFlag为false的时候，mainThread和Thread-0交替运行，当i等于50，即bFlag为true之后，不再去执行Thread-0