Java 多线程编程1----进程与线程

怼烎@ 2022-05-20 05:50 245阅读 0赞

**进程是程序的一次动态执行过程**，它经历了从代码加载，执行到执行完毕的一个完整过程。这个过程也是进程本身从产生，发展到最终消亡的过程。多进程操作系统能同时运行多个进程(程序),由于CPU具备分时机制，每个进程都能循环获取自己的CPU时间片。由于CPU执行速度非常快，使得所有程序`好像在同时运行`一样。  
多线程是实现并发机制的一种有效手段，进程和线程一样，都是实现并发的一个基本单位。线程是比进程跟小的执行单位，线程是在进程的基础之上进行的进一步划分。所谓多线程是指一个进程在执行过程中可以产生多个线程，这些线程可以同时存在，同时运行，一个进程可能包含了多个同时执行的线程。进程与线程的区别如下图所示  
![进程和线程的区别][70]

### 举个例子：Word程序 ###

使用过Word的应该都知道，在Word程序中如果出现了单词的拼写错误，则Word会在出现错误的单词下面划出红线。那么实际上每次启动一个Word对于操作而言就相当于启动了一个系统的进程，而在这个进程之上又有许多其他程序在运行(如拼写检查)，这些程序就是一个个的线程。如果Word关闭了，则这些拼写检查的线程也将会消失，但是即使拼写检查的线程消失了，也并不一定会让Word的进程消失。

在传统的程序语言中，运行的顺序从事必须按照程序的流程进程，而遇到if…else语句就加以判断，遇到for,while等循环就会多绕几圈，最后程序还是按着一定的程序运行，而且一次只能运行一个程序块。

所谓的线程(Thread)是指程序的运行流程，多线程机制则是指可以同时运行多个程序块，使程序运行的效率变得更高，也可克服传统编程语言所无法解决的问题。例如，有些包含循环的线程可能要使用一段时间来运算，此时就可让另一个线程来做其他处理。

## Java中线程的实现 ##

在`Java`中事项多线程有两种方式，一种是继承`Thread`类，另一种是实现`Runable`接口。下面来分别介绍。

### 继承Thread类实现线程 ###

Thread类是在java.lang包中定义的，一个类只要继承了Thread类，那么这个类就称为多线程操作类，在Thread子类，必须明确的覆写Thread类中的run()方法，此方法为线程的主体。  
**线程类的定义如下：**

class 类名程 extends Thread
    {
        属性...；//类中定义属性
        方法...；//类中定义方法
        //覆写Thread类中的run()方法，该方法是线程的主体
        public void run()
        {
        }
    }

**实例：继承Thread类实现多线程**

package my.extends1.thread1;
    class MyThread extends Thread
    {
        String threadName;
        public MyThread(String threadName)
        {
            this.threadName=threadName;
        }
        //重写run方法
        public void run()
        {
            for(int i=0;i<10;i++)
            {
                System.out.println(threadName+": "+i);
            }
            System.out.println("---------------------------");
        }
    }
    public class ThreadDemo1 { 
        public static void main(String[] args)
        {
            MyThread myThread1=new MyThread("线程1");
            MyThread myThread2=new MyThread("线程2");
            //这里有坑了
            myThread1.run();
            myThread2.run();
        }
    }

**运行结果：**

线程1: 0
    线程1: 1
    线程1: 2
    线程1: 3
    线程1: 4
    线程1: 5
    线程1: 6
    线程1: 7
    线程1: 8
    线程1: 9 ---------------------------
    线程2: 0
    线程2: 1
    线程2: 2
    线程2: 3
    线程2: 4
    线程2: 5
    线程2: 6
    线程2: 7
    线程2: 8
    线程2: 9 ---------------------------

多运行几次，可以发现，上面的程序的每次执行的结果都是和上面的一样，总是先执行线程1，在执行线程2.并没有像之前介绍的那样是交错运行的，也就是说，此时线程实际上并没有被启动，还是属于顺序执行的方式。  
那么该如何启动线程呢，**如果要正确的启动线程，是不能直接调用`run()`方法的。而是应该调用从`Thread`中继承而来的`start()`方法**  
把上面的两个run()方法改成start()即可  
**正确的例子：**

package my.extends1.thread1;
    class MyThread extends Thread
    {
        String threadName;
        public MyThread(String threadName)
        {
            this.threadName=threadName;
        }
        //重写run方法
        public void run()
        {
            for(int i=0;i<10;i++)
            {
                System.out.println(threadName+": "+i);
            }
            System.out.println("---------------------------");
        }
    }
    public class ThreadDemo1 { 
        public static void main(String[] args)
        {
            MyThread myThread1=new MyThread("线程1");
            MyThread myThread2=new MyThread("线程2");
            //正确启动线程的方法
            myThread1.start();
            myThread2.start();
        }
    }

运行结果(一种)：

线程1: 0
    线程2: 0
    线程1: 1
    线程2: 1
    线程1: 2
    线程2: 2
    线程1: 3
    线程2: 3
    线程1: 4
    线程2: 4
    线程1: 5
    线程2: 5
    线程1: 6
    线程2: 6
    线程1: 7
    线程2: 7
    线程1: 8
    线程2: 8
    线程1: 9
    线程2: 9 ---------------------------
    ---------------------------

从程序的运行结果中可以发现，两个线程现在是交错运行的，哪个线程对象抢到了CPU资源，哪个线程就可以运行，所以程序每次运行结果肯定是不一样的，在线程启动是虽然调用的start()方法，但是实际上调用的却是run()方法的主体。  
**注意了：启动线程调用start()方法，run()方法不能启动线程**

### 看一下start()方法在Thread类中的定义： ###

public synchronized void start() {
            if (threadStatus != 0)
                throw new IllegalThreadStateException();
            group.add(this);
            boolean started = false;
            try {
                start0();
                started = true;
            } finally {
                try {
                    if (!started) {
                        group.threadStartFailed(this);
                    }
                } catch (Throwable ignore) {
                }
            }
        }
        private native void start0();

从上面的源码中可以发现，在一个类中调用`start`()方法，可能会抛出`IllegalThreadStateException`异常，一般在重复调用`start()`方法会抛出这个异常，而且真正调用的是`start0()`这个方法，`start0()`方法在声明出，使用了`native`关键字修饰，`native`关键字表示调用的本机的操作系统函数，因为多线程的实现需要依靠低层操作系统的支持。

所以，如果一个类通过继承`Thread`类来实现，那么只能调用一次`start()`方法，如果多次调用，将会抛出`IllegalThreadStateException`异常。

### 错误的实例：重复调用start()方法 ###

在上面的代码中修改一下：

package my.extends1.thread1;
    class MyThread extends Thread
    {
        String threadName;
        public MyThread(String threadName)
        {
            this.threadName=threadName;
        }
        //重写run方法
        public void run()
        {
            for(int i=0;i<10;i++)
            {
                System.out.println(threadName+": "+i);
            }
            System.out.println("---------------------------");
        }
    }
    public class ThreadDemo1 { 
        public static void main(String[] args)
        {
            MyThread myThread1=new MyThread("线程1");
    // MyThread myThread2=new MyThread("线程2");
            //错误的启动线程的方法
    // myThread1.run();
    // myThread2.run();
            //正确启动线程的方法
    // myThread1.start();
    // myThread2.start();
            //不能重复调用start()方法,调用一次就够了
            myThread1.start();
            myThread1.start();
    
        }
    }

**运行结果：**

Exception in thread "main" java.lang.IllegalThreadStateException
    线程1: 0  at java.lang.Thread.start(Unknown Source)
    
    线程1: 1
    线程1: 2
    线程1: 3
    线程1: 4  at my.extends1.thread1.ThreadDemo1.main(ThreadDemo1.java:33)
    
    线程1: 5
    线程1: 6
    线程1: 7
    线程1: 8
    线程1: 9
    ---------------------------

如果通过继承`Thread`类来实现多线程，则会受到单继承局限的影响，所以一般来说，要想实现多线程可以通过实现`Runable`接口来完成。

## 实现Runable接口 ##

在Java中也可以通过实现Runable接口的方式实现多线程，Runable接口中只定义了一个重现方法：

public void run()；

**实例：通过实现Runable接口方式实现多线程**

public class MyThread implements Runnable { 
        private String name;
        public MyThread(String name)
        {
            this.name=name;
        }
        @Override
        public void run()
        {
            for(int i=0;i<10;i++)
            {
                System.out.println("线程："+name+"执行第 "+i+" 次");
            }
        }
    }

以上代码通过Runable接口实现了多线程，但是这样一来就有新的问题产生了，从上面可以知道，要想启动线程，必须要使用start()方法完成。如果是继承了Thread类，这可以直接使用从Thread类继承来的start()方法，但是这里实现的是Runable接口，Runable接口中没有start()方法可以直接使用。那么该怎么启动线程呢?实际上此时还是依靠Thread类完成启动，在Thread类中提供了public Thread(Runnable target)和public Thread(Runable targer,String name)两个构造方法。  
这两个构造方法都可以接收Runable的实例对象，所以就可以靠才这两个方法启动多线程，具体代码如下。  
**实例：使用Thread类启动实现Runable接口方式的线程**

package my.implement.runable;
    
    public class StartRunable { 
        public static void main(String[] args)
        {
            //实例化Runable实例对象
            MyThread th1=new MyThread("线程1");
            MyThread th2=new MyThread("线程2");
            //实例化Thread类对象
            Thread t1=new Thread(th1);
            Thread t2=new Thread(th2);
            //启动线程
            t1.start();
            t2.start();
        }
    }

**运行结果：**

线程：线程2执行第 0 次
    线程：线程1执行第 0 次
    线程：线程2执行第 1 次
    线程：线程1执行第 1 次
    线程：线程2执行第 2 次
    线程：线程1执行第 2 次
    线程：线程2执行第 3 次
    线程：线程1执行第 3 次
    线程：线程2执行第 4 次
    线程：线程1执行第 4 次
    线程：线程2执行第 5 次
    线程：线程1执行第 5 次
    线程：线程1执行第 6 次
    线程：线程2执行第 6 次
    线程：线程2执行第 7 次
    线程：线程2执行第 8 次
    线程：线程2执行第 9 次
    线程：线程1执行第 7 次
    线程：线程1执行第 8 次
    线程：线程1执行第 9 次

从一样两种方式，可以发现，不论是通过继承Thread类方式实现多线程操作，还是通过继承Runable接口方式实现多线程，都需要借助Thread类的start()方法才能启动多线程。

## Thread类和Runable接口 ##

通过Thread类和Runabel接口都实现多线程，那么两着有什么联系和区别？  
**Thread类的定义：**

public class Thread implements Runnable

从Thread类的定义可以清楚的发现，Thread类是Runable接口的实现类。但是在Thread中的run()方法和Runable方法不一样。见如下的Thread源码  
**Thread部分源码：**

public Thread(Runnable target) {
            init(null, target, "Thread-" + nextThreadNum(), 0);
        }
        public Thread(Runnable target, String name) {
            init(null, target, name, 0);
        }
        private void init(ThreadGroup g, Runnable target, String name,
                          long stackSize) {
            init(g, target, name, stackSize, null);
        }
        private void init(ThreadGroup g, Runnable target, String name,
                          long stackSize, AccessControlContext acc) {
        ......
            this.target = target;
        ......
        }
        public void run() {
            if (target != null) {
                target.run();
            }
        }

从Thread类的定义中可以发现，Thread类中的run方法调用的是Runable接口中的run()方法，也就是说此run方法是Runable的实现类完成的，所以如果要通过继承Thread类实现多线程，则必须覆写run()方法。  
Thread和Runable的实现类都是同时实现Runable接口，之后将Runable的实现类放到Thread类之中。

### Thread类方式和实现Runable接口之间在使用上的区别 ###

如果一个类继承Thread类，则不适合用于多个线程共享资源，而实现Runable接口，就可很方便的实现资源的共享。  
**实例：继承Thread类不能资源共享**

package my.thread_runable;
    class MyThread extends Thread
    {
        private String name;
        int ticket=5;
        public MyThread(String name)
        {
            this.name=name;
        }
        @Override
        public void run()
        {
            for(int i=0;i<10;i++)
            {
                if(ticket>0)
                {
                    System.out.println(name+"买掉一张,"+"余票"+ticket--);
                }
            }
        }
    }
    
    public class ThreadDemo { 
        public static void main(String[] args)
        {
            MyThread myth1=new MyThread("A");
            MyThread myth2=new MyThread("B");
            MyThread myth3=new MyThread("C");
            myth1.start();
            myth2.start();
            myth3.start();
        }
    }

**运行结果：**

B买掉一张,余票5
    A买掉一张,余票5
    C买掉一张,余票5
    A买掉一张,余票4
    C买掉一张,余票4
    B买掉一张,余票4
    A买掉一张,余票3
    B买掉一张,余票3
    C买掉一张,余票3
    B买掉一张,余票2
    A买掉一张,余票2
    B买掉一张,余票1
    C买掉一张,余票2
    C买掉一张,余票1
    A买掉一张,余票1

以上程序通过继承Thread类实现多线程，程序中启动了三个线程，但是这三个线程却都各自卖掉了5张票，同一张票被卖了三次，说明这三个线程各拥有一份ticket变量。不是三个线程共同持有一个ticket变量，这样没有达到资源(ticket)共享的目的。  
这样的原因是ticket变量是没有用static修饰，是对象变量，创建对象的时候，每个对象都有自己各自的一份ticket。所以每个线程都卖掉自己的那份ticket,所以出现了可以卖三次的情况。  
要想这样共享ticket变量的话可以 在ticket变量前面加上static修饰符，吧ticket变成类变量，这样三个线程就能贡献该ticket变量了。  
**实例：实现Thread方式实现的线程只能共享静态变量**

package my.thread_runable;
    
    
    
    class MyThread1 extends Thread
    {
        private String name;
        static int ticket=5;
        public MyThread1(String name)
        {
            this.name=name;
        }
        @Override
        public void run()
        {
            for(int i=0;i<10;i++)
            {
                if(ticket>0)
                {
                    System.out.println(name+"买掉一张,"+"余票"+ticket--);
                }
            }
        }
    }
    
    public class ThreadDemo2 { 
        public static void main(String[] args)
        {
            MyThread1 myth1=new MyThread1("A");
            MyThread1 myth2=new MyThread1("B");
            MyThread1 myth3=new MyThread1("C");
            myth1.start();
            myth2.start();
            myth3.start();
        }
    }

运行结果：

B买掉一张,余票5
    C买掉一张,余票4
    A买掉一张,余票5
    C买掉一张,余票2
    B买掉一张,余票3
    A买掉一张,余票1

可以看到继承Thread类方式的线程是可以共享静态变量的，但不能共享非静态变量。  
那能不能就创建一个MyThread 对象，然后多次启动呢，进入实现多个线程，共享非静态变量呢？在上面的分析中，我们知道通过继承Thread方式实现的线程是不能多次启动的。所以这个方法不可行。

### 实现Runable接口的线程可以多次启动，进而共享实现类中的非静态变量。 ###

通过实现Runable接口方式实现线程，可以启动多次。这样我们就可以只需要件一个Runable接口的实现类的对象，然后多次启动，这时候就有多个线程在运行，这些线程共同操作一个Runable接口的实现类的对象，也就是多个线程共享一个Runable接口的实现类的对象，例子如下：  
**实例：实现Runable接口方式的的线程可以多次启动**

package my.thread_runable;
    class MyRunable implements Runnable
    {
        private String name;
        private int ticket=10;
        int count=-1;
    
        @Override
        public void run()
        {
            count++;
            for(int i=0;i<20;i++)
            {
                if(ticket>0)
                {
                    System.out.println((char)('A'+count)+"卖掉了一张票,余票:"+ticket--);
                }
            }
    
        }
    }
    
    public class RunableDemo { 
        public static void main(String[] args)
        {
            MyRunable myrun1=new MyRunable();
            //创建3个线程，这3个线程共同操作myrun1这个实例对象
            Thread myth1=new Thread(myrun1);
            Thread myth2=new Thread(myrun1);
            Thread myth3=new Thread(myrun1);
            myth1.start();
            myth2.start();
            myth3.start();
        }
    }

**程序运行结果：**

A卖掉了一张票,余票:10
    B卖掉了一张票,余票:9
    B卖掉了一张票,余票:8
    C卖掉了一张票,余票:5
    C卖掉了一张票,余票:4
    C卖掉了一张票,余票:3
    C卖掉了一张票,余票:2
    C卖掉了一张票,余票:1
    B卖掉了一张票,余票:7
    C卖掉了一张票,余票:6

从程序的运行结果可以清楚的发现，这里总共有10张票，虽然启动了三个线程，但是3个线程一共才卖掉了10张票，即ticket属性被所有线程共享。  
**要实现非静态资源的共享，必须是多个线程共同操作一个Runable实现类的对象**

如果分别创建了3个MyRunable对象的实例，然后在分别启动这三个MyRunable对象，每个线程操作一个MyRunable对象，不是3个线程操作一个对象，所以存在资源共享的这一说法。  
**错误的实例：创建3个MyRunable实例，然后每个启动一次**

package my.thread_runable;
    
    class MyRunable1 implements Runnable
    {
        private String name;
        private int ticket=5;
        int count=-1;
        public MyRunable1()
        {
        }
        MyRunable1(String name)
        {
            this.name=name;
        }
        @Override
        public void run()
        {
            for(int i=0;i<20;i++)
            {
                if(ticket>0)
                {
                    System.out.println(name+"卖掉了一张票,余票:"+ticket--);
                }
            }
    
        }
    }
    
    public class RunableDemo1 { 
        public static void main(String[] args)
        {
            //创建了3个Runable接口实例
            MyRunable1 myrun1=new MyRunable1("A");
            MyRunable1 myrun2=new MyRunable1("B");
            MyRunable1 myrun3=new MyRunable1("C");
            //创建3个线程，每个线程操作一个Runable接口实例
            Thread myth1=new Thread(myrun1);
            Thread myth2=new Thread(myrun2);
            Thread myth3=new Thread(myrun3);
            myth1.start();
            myth2.start();
            myth3.start();
        }
    }

**运行结果：**

A卖掉了一张票,余票:5
    B卖掉了一张票,余票:5
    B卖掉了一张票,余票:4
    B卖掉了一张票,余票:3
    A卖掉了一张票,余票:4
    B卖掉了一张票,余票:2
    A卖掉了一张票,余票:3
    B卖掉了一张票,余票:1
    C卖掉了一张票,余票:5
    C卖掉了一张票,余票:4
    C卖掉了一张票,余票:3
    A卖掉了一张票,余票:2
    C卖掉了一张票,余票:2
    C卖掉了一张票,余票:1
    A卖掉了一张票,余票:1

可以看到，上面的代码中分别创建了三个MyRunable1的对象myrun1，myrun2，myrun3，然后在分别创建三个线程myth1，myth2，myth3。  
这里线程myth1执行的myrun1中run()方法,卖的票是myrun1中的票。myth2执行的是myrun2中的run()方法，卖的票是myrun2中的票，myth3执行的是myrun3中的run()方法，卖的票是myrun3中的票。这三个对象中的票不是同一个票，所以不是线程共享同一个资源。

实现Runable接口方式对于继承Thread方式来说，有如下显著的优势。

*  适合多个相同程序代码的线程去处理同一资源的情况
 *  可以避免由于java单继承特性带来的局限性。
 *  增强了程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。
    
    所以在开发中建议使用Runable接口实现多线程。

[70]: /images/20220520/d6b90d78242e4165836cf7dbb4c3f6aa.png