Java多线程（一）

 

线程与进程

1、线程：进程中负责程序执行的执行单元，线程本身依靠程序进行运行，线程是程序中的顺序控制流，只能使用分配给程序的资源和环境；

2、进程：执行中的程序，一个进程至少包含一个线程；

3、单线程：程序中只存在一个线程，实际上主方法就是一个主线程；

4、多线程：在一个程序中运行多个任务，目的是更好地使用CPU资源。

线程的实现

Java中有两种方法实现多线程：1、继承Thread类       2、实现 Runnable 接口

一、继承Thread类

Thread 类最重要的方法是 run（），它为Thread 类的方法 start（） 所调用，提供我们的线程所要执行的代码。我们在创建Thread 类的子类中重写 run（） ，加入线程所要执行的代码即可。

public class MyThread extends Thread {

    int count = 1;
    int number;
    
    public MyThread(int num) {
        this.number = num;
        System.out.println("创建线程 " + number);
    }
    
    @Override
    public void run() {
        while(true) {
            System.out.println("线程 " + number + ": 计数" + count);
            if(++count == 3) {
                return;
            }
        }
    }
    
    public static void main(String[] args) {
        for(int i=0; i<3; i++) {
            new MyThread(i+1).start();
        }
    }
    
}

输出结果：

创建线程 1
创建线程 2
创建线程 3
线程 1: 计数1
线程 3: 计数1
线程 2: 计数1
线程 3: 计数2
线程 1: 计数2
线程 2: 计数2

二、实现 Runnable 接口

Runnable 接口只有一个方法 run（），我们声明自己的类实现 Runnable 接口并提供这一方法，将我们的线程代码写入其中，就完成了这一部分的任务。

但是 Runnable 接口并没有任何对线程的支持，我们还必须创建 Thread 类的实例，这一点通过 Thread 类的构造函数public Thread（Runnable target）来实现。

public class MyRunnable implements Runnable{

    int count = 1;
    int number;
    
    public MyRunnable(int num) {
        this.number = num;
        System.out.println("创建线程 " + number);
    }
    
    @Override
    public void run() {
        while(true) {
            System.out.println("线程 " + number + ": 计数" + count);
            if(++count == 3) {
                return;
            }
        }
    }
    
    public static void main(String[] args) {
        for(int i=0; i<4; i++) {
            new Thread(new MyRunnable(i+1)).start();
        }
    }
}

输出结果：

创建线程 1
创建线程 2
线程 1: 计数1
线程 1: 计数2
创建线程 3
线程 2: 计数1
线程 2: 计数2
创建线程 4
线程 3: 计数1
线程 3: 计数2
线程 4: 计数1
线程 4: 计数2

实现Runnable接口相对于继承Thread类的优点

1、适合多个相同程序代码的线程去处理同一个资源

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

3、增强了程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。

下面通过实现简单的卖票场景来印证上述问题：

public class Tickets implements Runnable{

    private int ticket = 10;
    
    @Override
    public void run() {
        for(int i=0; i<100; i++) {    //定义一个超过票数的循环
            if(ticket>0) {
                System.out.println(Thread.currentThread().getName() + " sale:" + ticket--);    //显示余票
            }
        }
    }
    
    /*
     * 如果实例化两个对象，比如实例化ticket1再实例化一个ticket2你会发现两个不同的线程没有共享ticket
     * 但是如果MyThread是继承Thread类而不是实现接口Runnable,下面的代码将报错。
     * */
    public static void main(String[] args) {
        Tickets ticket = new Tickets();
        Thread t1 = new Thread(ticket);
        Thread t2 = new Thread(ticket);
        Thread t3 = new Thread(ticket);
        Thread t4 = new Thread(ticket);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
    
}

输出结果：

Thread-0 sale:10
Thread-3 sale:8
Thread-2 sale:9
Thread-2 sale:4
Thread-2 sale:3
Thread-2 sale:2
Thread-2 sale:1
Thread-3 sale:5
Thread-1 sale:6
Thread-0 sale:7

public class Tickets extends Thread {

    private int ticket = 10;
    
    @Override
    public void run() {
        for(int i=0; i<100; i++) {    //定义一个超过票数的循环
            if(ticket>0) {
                System.out.println(Thread.currentThread().getName() + " sale:" + ticket--);    //显示余票
            }
        }
    }
    
    /*
     * 如果实例化两个对象，比如实例化ticket1再实例化一个ticket2你会发现两个不同的线程没有共享ticket
     * 但是如果MyThread是继承Thread类而不是实现接口Runnable,下面的代码将报错。
     * */
    public static void main(String[] args) {
        Tickets ticket1 = new Tickets();
        Tickets ticket2 = new Tickets();
        ticket1.start();
//        ticket1.start();    //如果同时启动两个ticket1的线程，会报错
        ticket2.start();
    }
}

输出结果：

Thread-1 sale:10
Thread-0 sale:10
Thread-1 sale:9
Thread-0 sale:9
Thread-1 sale:8
Thread-0 sale:8
Thread-1 sale:7
Thread-0 sale:7
Thread-1 sale:6
Thread-0 sale:6
Thread-1 sale:5
Thread-0 sale:5
Thread-1 sale:4
Thread-0 sale:4
Thread-1 sale:3
Thread-0 sale:3
Thread-0 sale:2
Thread-1 sale:2
Thread-0 sale:1
Thread-1 sale:1