Java oop 第13章

第13章_多线程

一、 多线程相关的概念：

程序：由某种编程语言开发可执行某些功能的代码组合，它是静态的概念。
进程：当程序被执行时的过程可以理解为讲程序从外存调入内存的过程，会为每一个程序至少开辟一个独立的内存空间，程序在内存中的状态称为一个进程。
线程：一个进程至少会有一个独立的内存空间，但线程是依附在进程的内存空间中工作的，因此它没有自己的独立内存空间，多个线程会共用一个进程的内存空间。
多线程开发：往往一个进程中可以包含多个线程，多线程开发就是要具体实施一个进程中执行（启动）多个线程。

二、 Java中如何实现多线程开发：

通过继承Thread类，并重写Run方法完成多线程开发。

　　　　当一个类继承Thread父类就可以通过该类调用start()方法启动线程，创建多个对象就可以启动多个线程，run()方法是在启动线程时由JVM调用执行。

　　　　代码参考：com.oop.ch13.ThreadTest

package com.oop.ch13;

/**

 * 练习通过继承Thread类，并重写Run()方法完成多线程开发。

 *

 */

public class ThreadTest {

    public static void main(String[] args) {

        Person person = new Person();

        person.start();

        Person person1 = new Person();

        person1.start();

        Person person2 = new Person();

        person2.start();

    }

}

class Person extends Thread {

    @Override

    public void run() {

        Integer nums = 1;

        while (true) {

            if (nums <= 5) {

                System.out.println(Thread.currentThread().getName() + "线程第" + nums + "次输出");

                try {

                    Thread.sleep(2000);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                nums++;

            } else {

                System.out.println("执行完成");

                break;

            }

        }

    }

}

通过实现Runnable接口，并实现Run方法完成多线程开发。

　　　　因为Java是一个单继承的编程语言，因此为了完成多线程开发，我们可能通常会直接实现Runnable接口，而不是继承Thread父类。

　　　　当一个类实现Runnable接口后，在创建Thread对象时可以将实现了Runnable的实现类对象作为参数，从而通过Thread的对象来启动多个线程。

　　　　代码参考：com.oop.ch13.RunnableTest

package com.oop.ch13;

/**

 * 练习：通过实现Runnable接口，并实现Run方法完成多线程开发。

 *

 */

public class RunnableTest {

    public static void main(String[] args) {

        Animal animal  = new Animal();

        //将Animal的对象作为参数传给Thread

        Thread thread1 = new Thread(animal);

        thread1.start();

        Thread thread2 = new Thread(animal);

        thread2.start();

        Thread thread3 = new Thread(animal);

        thread3.start();

    }

}

class Animal implements Runnable{

    @Override

    public void run() {

        Integer nums = 1;

        while (true) {

            if (nums <= 5) {

                System.out.println(Thread.currentThread().getName() + "线程第" + nums + "次输出");

                try {

                    Thread.sleep(2000);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                nums++;

            } else {

                System.out.println("执行完成");

                break;

            }

        }

    }

}

三、 解决多线程开发中存在的问题：

　　问题：在进行多线程开发时会存在线程安全的问题（同步问题），多个线程共用一个进程的内存空间，访问的变量、方法都是同一个。

　　解决方案：使用一个解决同步问题的关键字synchronized，具体使用方式有两种。

　　方式1：使用synchronized关键字修饰方法，方法就为同步方法；

　　方式2：使用synchronized关键字修饰一段代码块，编写一段同步代码块。

　　案例描述：模拟“机票销售系统”，多个窗口会销售同一个航班的票，要保证机票不能出现多个窗口销售同一张机票的情况。

　　代码参见：

　　com.oop.ch13.WindowTest

package com.oop.ch13;

/**

 * 模拟“机票销售系统”，多个窗口会销售同一个航班的票，要保证机票不能出现多个窗口销售同一张机票的情况。

 * 没有进行同步处理。

 *

 */

public class WindowTest {

    public static void main(String[] args) {

        Window window = new Window();

        Thread thread1 = new Thread(window);

        thread1.start();

        Thread thread2 = new Thread(window);

        thread2.start();

        Thread thread3 = new Thread(window);

        thread3.start();

    }

}

class  Window implements Runnable{

    @Override

    public void  run() {

        Integer nums = 20;

        while(true) {

            if (nums >0) {

                System.out.println(Thread.currentThread().getName() + "销售了剩余的第" + nums + "张票");

                try {

                    Thread.sleep(1000);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                nums --;

            }else {

                System.out.println("机票销售完成");

                break;

            }

        }

    }

}

　　com.oop.ch13.WindowSynchronizedTest

package com.oop.ch13;

/**

 * 模拟“机票销售系统”，多个窗口会销售同一个航班的票，要保证机票不能出现多个窗口销售同一张机票的情况。

 *

 * 进行同步处理。

 *

 */

public class WindowSynchronizedTest {

    public static void main(String[] args) {

        Windows windows = new Windows();

        Thread thread1 = new Thread(windows);

        thread1.start();

        Thread thread2 = new Thread(windows);

        thread2.start();

        Thread thread3 = new Thread(windows);

        thread3.start();

    }

}

class Windows implements Runnable {

    //声明为成员变量，这样多个线程共用的才是同一个变量，否则每个线程都会运行一遍run()方法

    Integer nums = 20;

    @Override

    /*

     * 用synchronized关键字修饰一段代码块

     * 或用synchronized修饰方法，就是同步方法

     * public void synchronized run(){}

     *

     */

    public void run() {

        while (true) {

            //同步处理

            synchronized (this) {

                if (nums > 0) {

                    System.out.println(Thread.currentThread().getName() + "销售了剩余的第" + nums + "张票");

                    try {

                        Thread.sleep(100);

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                    nums--;

                } else {

                    System.out.println("机票销售完成");

                    break;

                }

            }

        }

    }

}

四、 线程的五种状态：

1、 创建（New）：

2、 就绪（Runnable）：

3、 运行（Running）：

4、 阻塞（Blocked）：

5、 死亡（Dead）：

巴特西

Java oop 第13章_多线程

最新文章

热门文章