多线程学习笔记

---

前言

  java学习中多线程是比较重要的知识点，本篇内容是本人学习多线程的学习笔记。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、线程是什么？

  线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。

二、线程的创建方式

1.继承Thread类

步骤

  1.创建一个继承于Thread类的子类
  2.重写Thread类的run() —>将此线程要执行的操作，声明在此方法体中
  3.创建当前Thread类的子类的对象
  4.通过对象调用start()：1）启动线程；2）调用当前线程的run()

示例

创建一个分线程1，用于遍历100以内的偶数；
代码如下：

//1.创建一个继承于Thread类的子类
class PrintNumber extends Thread {

    //2.重写Thread类的run() --> 将此线程要执行的操作，声明在此方法体中
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
public class EvenNumberTest {
    public static void main(String[] args) {
        
        //3.创建当前Thread的子类的对象
        PrintNumber p1=new PrintNumber();
        //4.通过对象调用start()
        p1.start();
        
        //main()所在的线程执行的操作
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

2.实现Runnable接口

步骤

  1.创建一个实现Runnable接口的类
  2.实现接口中的run() —>将此线程要执行的操作，声明在此方法体中
  3.创建当前实现类的对象
  4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的实例
  5.Thread类的实例调用start()：1）启动线程；2）调用当前线程的run()

示例

创建分线程遍历100以内的偶数

代码如下（示例）：

//1.创建一个实现Runnable接口的类
class EvenNumberPrint implements Runnable {
    //2.重写接口中的run() --> 将此线程要执行的操作，声明在此方法体中
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class EvenNumberTest {
    public static void main(String[] args) {
        //3.创建当前实现类的对象
        EvenNumberPrint p=new EvenNumberPrint();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的实例
        Thread t1=new Thread(p);
        //5.Thread类的实例调用start()：1）启动线程；2）调用当前线程的run()
        t1.start();

        //main()所在的主线程执行的操作
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

【扩展】再创建一个线程，用于遍历100以内的偶数；
代码如下（示例）：

//1.创建一个实现Runnable接口的类
class EvenNumberPrint implements Runnable {
    //2.重写接口中的run() --> 将此线程要执行的操作，声明在此方法体中
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class EvenNumberTest {
    public static void main(String[] args) {
        //3.创建当前实现类的对象
        EvenNumberPrint p=new EvenNumberPrint();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的实例
        Thread t1=new Thread(p);
        //5.Thread类的实例调用start()：1）启动线程；2）调用当前线程的run()
        t1.start();

        //main()所在的主线程执行的操作
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }

        /**
         * 扩展：再创建一个线程，用于遍历100以内的偶数
         */
        Thread t2=new Thread(p);
        t2.start();
    }
}

三、方式对比

【扩展】创建两个分线程，其中一个线程遍历100以内的偶数，另一个线程遍历100以内的奇数；
代码如下：

class EvenNumberPrint extends Thread {//用于打印偶数

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

class OddNumberPrint extends Thread {//用于打印奇数

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + "--->" + i);
            }
        }
    }
}

public class PrintNumberTest {
    public static void main(String[] args) {
        //方式一：
        EvenNumberPrint t1 = new EvenNumberPrint();
        OddNumberPrint t2 = new OddNumberPrint();

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

        //方式二：创建Thread类的匿名子类的匿名对象
        new Thread() {
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    if (i % 2 == 0) {
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();

        new Thread() {
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    if (i % 2 != 0) {
                        System.out.println(Thread.currentThread().getName() + "--->" + i);
                    }
                }
            }
        }.start();

        //方式三：使用实现Runnable接口的方式：（提供了Runnable接口匿名实现类的匿名对象）
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    if (i % 2 == 0) {
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    if (i % 2 != 0) {
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }).start();
    }
}

1.共同点

  1）启动线程，使用的都是Thread类中定义的start()
  2）创建的线程对象，都是Thread类或其子类的实例

2.不同点

  一个是类的继承，一个是接口的实现

3.建议

  建议使用Runnable接口的方式

Runnable方式的好处：
1）实现的方式：避免的类的单继承的局限性；
2）更适合处理有共享数据的问题；
3）实现了代码和数据的分离

  联系：public class Thread implements Runnable (代理模式)

---

总结

  本文是本人学习多线程的一个学习笔记，仅供参考。