课程8.0之线程

---

转发请注明出处：
安卓猴的博客（http://sunjiajia.com）

---

本节课程将学习以下内容：

• 进程和线程的关系
• 多线程程序运行模式
• 定义线程的方法
• 控制线程的常用函数
• 多线程的数据安全
• 同步线程的方法
• 深入synchronized关键字

---

进程和线程的关系

多进程：

在操作系统中能（同时）运行多个任务（程序）。

多线程：

在同一个应用程序中有多个顺序流（同时）进行。

多线程程序运行模式

线程的执行过程：

图8—0—01。线程执行过程

定义线程的方法

方法1：

定义一个线程类，它继承类Thread并重写其中的方法run()，方法run()称为线程体；

方法2：

提供一个实现接口Runnable的类作为线程的目标对象，在初始化一个Thread类或者Thread子类的线程对象时，把目标对象传递给这个线程实例，由该目标对象提供线程体。

例子1：

1.新建一个FirstThread.java的源文件：

class FirstThread extends Thread {
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println("FirstThread-->" + i);
        }
    }
}

2.新建一个Demo01.java的源文件：

class Demo01 {
    public static void main(String[] args) {
        // 生成线程类的对象
        FirstThread thread01 = new FirstThread();
        // 启动线程
        thread01.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("main-->" + i);
        }
    }
}

3.新建一个RunnableImpl.java的源文件：

class RunnableImpl implements Runnable {
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("Runnable-->" + i);
        }
    }
}

4.新建一个Demo02.java的源文件：

class Demo02 {
    public static void main(String[] args) {
        // 生成一个Runnable接口实现类的对象
        RunnableImpl ri = new RunnableImpl();
        // 生成一个Thread对象，并将Runnable接口实现类的对象作为参数传递进去
        Thread t = new Threadj(ri);
        t.start();

        // 打印当前线程的优先级
        // 默认优先级是5，最大优先级是10，最小优先级是1。
        // 线程的优先级越高，它执行的概率就越大。
        System.out.println(t.getPriority());

        t.setPriority(Thread.MAX_PRIORITY);

    }
}

控制线程的常用函数

中断线程：

Thread.sleep(2000);线程睡眠2000毫秒。
Thread.yield();线程自动让出cpu。

设置线程的优先级：

getPriority();
setPriority();

多线程的数据安全

同步线程的方法

• 多线程共用同一份数据的时候，会出现某种错误；
• 因此需要在同步线程。

例子2：

1.新建一个MyThread.java的源文件：

class MyThread implements Runnable {
    int i = 100;
    public void run(){
        while (true) {
            // 同步代码块
            // 解决多线程共用同一份数据时出现错误的问题
            synchronized (this) {
                System.out.println(Thread.currentThread().getName() + i);
                i--;
                Thread.yield();
                if (i < 0) {
                    break;
                }
            }
        }
    }
}

2.新建一个Demo03.java的源文件：

class Demo03 {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();

        // 生成两个Thread对象，但是这两个对象共用同一个线程体
        Thread t1 = new Thread(myThread);
        Thread t2 = new Thread(myThread);

        // 每一个线程都有名字，可以通过Thread对象的setName()方法设置
        t1.setName("线程a");
        t2.setName("线程b");

        // 分别启动两个线程
        t1.start();
        t2.start();
    }
}

深入synchronized关键字

同步锁，它锁住的是对象。
如果一个线程获得了一个对象的同步锁，那么这个对象上面的所有的其它的同步代码都是不能够被其它线程执行的，都需要等待同步锁被释放后，才能够进行。

例子3：

1.新建一个名为Service.java的源文件：

class Service {
    public voi fun1 () {
        synchronized (this) {
            try {
                Thread.sleep(3000);
            } catch (Exception e) {
                System.out.println(e);
            }
            System.out.println("fun1");
        }
    }

    // fun2是一个同步方法，和fun1中的同步代码块功能一样
    public synchronized voi fun2 () {
            System.out.println("fun2");
    }
}

2.新建一个名为MyThread1.java的源文件：

class MyThread1 implements Runnable {
    private Service service;

    public MyThread1 (Service service) {
        this.service = service;
    }

    public void run () {
        service.fun1();
    }

}

3.新建一个名为MyThread2.java的源文件：

class MyThread2 implements Runnable {
    private Service service;

    public MyThread2 (Service service) {
        this.service = service;
    }

    public void run () {
        service.fun2();
    }

}

4.新建一个名为Demo04.java的源文件：

class Demo04 {
    public static void main(String[] args) {
        Service service = new Service();

        Thread t1 = new Thread(new MyThread1(service));
        Thread t2 = new Thread(new MyThread2(service));

        t1.start();
        t2.start();
    }
}