多线程编程（一）

傷城~ 2021-11-14 13:46 416阅读 0赞

## 概念 ##

进程：受操作系统管理的基本运行单元  
线程：在进程中独立运行的子任务，是操作系统能够进行运算调度的最小单位，一个进程中至少有一个线程，可以有多个线程  
单线程：一个进程中只有一个线程  
多线程：一个进程中的线程多余一个，多线程是异步执行的  
**多线程**  
优点：能够充分的利用CPU，提高代码的响应速度  
缺点：线程太多，线程之前的切换

## 线程的使用方式 ##

1、继承Thread类  
任务执行类

public class MyThread extends Thread {
        @Override
        public void run(){
            System.out.println("MyThread");
        }
    }

运行类代码

public static void main(String[] args) {
            MyThread t1 = new MyThread();
            t1.start();
            System.out.println("运行结束");
        }

运行结果  
![在这里插入图片描述][20190731222337294.png]  
2、实现Runnable接口  
由于Java是单继承的，所以一个类如果已经继承了一个父类，那么这个类就不能再继承Thread类了，这个时候就可以实现Runnable接口来达到与继承Thread类同样的效果  
任务执行类

public class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("MyThread");
        }
    }

运行类代码

public class TestMyRunnable {
        public static void main(String[] args) {
            MyRunnable myRunnable = new MyRunnable();
            Thread thread = new Thread(myRunnable);
            thread.start();
            System.out.println("运行结束");
        }
    }

![在这里插入图片描述][20190731223444965.png]  
**线程调用的随机性**  
从上面的代码运行的结果来看，线程的调用是随机的

## 实例变量与线程安全 ##

在自定义的线程类中，实例变量有共享与不共享之分，下面是实例不共享的例子  
任务执行类

public class MyThread extends Thread {
    
        private int count = 5;
    
        public MyThread(String name) {
            super(name);
            this.setName(name);
        }
    
        @Override
        public void run() {
            while (count > 0) {
                System.out.println("Thread" + Thread.currentThread().getName() + ":" + count);
            }
        }
    }

运行类代码

public class TestMyThread {
        public static void main(String[] args) {
            MyThread t1 = new MyThread("A");
            MyThread t2 = new MyThread("B");
            MyThread t3 = new MyThread("C");
            MyThread t4 = new MyThread("D");
            t1.start();
            t2.start();
            t3.start();
            t4.start();
        }
    }

运行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NldmVubGl1eGlu_size_16_color_FFFFFF_t_70]  
**变量共享**  
任务执行类

public class MyThread extends Thread {
    
        private int count = 5;
        public MyThread(String name) {
            super(name);
            this.setName(name);
        }
    
        @Override
        public void run() {
            // 这里不要使用for循环，因为使用同步后其他线程就得不到运行的机会了
            count--;
            System.out.println("Thread" + Thread.currentThread().getName() + ":" + count);
        }
    }

运行类代码

public class TestMyThread {
        public static void main(String[] args) {
            MyThread t1 = new MyThread("A");
            Thread thread1 = new Thread(t1);
            Thread thread2 = new Thread(t1);
            Thread thread3 = new Thread(t1);
            Thread thread4 = new Thread(t1);
            thread1.start();
            thread2.start();
            thread3.start();
            thread4.start();
        }
    }

运行结果  
![在这里插入图片描述][20190731230139875.png]  
从上面的结果来看是线程不安全的，为了线程安全，我们可以在run方法上加上synchronized关键字，结果如下  
![在这里插入图片描述][2019073123081793.png]

[20190731222337294.png]: /images/20211114/8e29ae75b0a34a7ebc4aea704766b7e9.png
[20190731223444965.png]: /images/20211114/a8a9e18a6de24312b9cc0e393b9f34e0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NldmVubGl1eGlu_size_16_color_FFFFFF_t_70]: /images/20211114/0aa23cfb3cc948f88bdaf65ad9219353.png
[20190731230139875.png]: /images/20211114/bb127dcdce074d4f847d030e71910b67.png
[2019073123081793.png]: /images/20211114/dcfc9729809842d99402b81242e85d46.png