多线程教程+简单实现案例

﹏ヽ暗。殇╰゛Y 2022-11-16 13:49 163阅读 0赞

### Java多线程 ###

*  总结内容
 *   *  1. 进程是什么，线程又是什么
     *  2. 进程和线程的区别
     *  3. 为什么要学习多线程
     *  4. 实现多线程的方式
     *  5. 两种实现多线程方法的区别
     *  6. 多线程的同步（线程锁机制）
     *  7、多线程常用方法
     *  8、多线程综合案例
 *  总结

# 总结内容 #

## 1. 进程是什么，线程又是什么 ##

进程就是正在运行的程序，是操作系统运行程序是产生的，它是独立存在的，进程之间互不干扰。  
线程是进程的一个子集，是进程中的实际运作单位，开发人员可以通过操作线程进行多处理器编程。

## 2. 进程和线程的区别 ##

*  根本区别：  
    进程是操作系统分配资源的基本单位；  
    线程是CPU调度和执行的基本单位；
 *  其他区别：  
    操作系统中可以同时运行多个进程，一个进程又可以执行多个线程。系统在运行的时候会为每个进程分配不同的内存空间；而对线程而言，除了CPU外，系  
    统不会为线程分配内存（线程所使用的资源来自其所属进程的资源），线程组之间只能共享资源。

## 3. 为什么要学习多线程 ##

1）在耗时的操作时使用线程，可以提高程序运行的速度  
2）在并行操作时使用线程，提高并行的速度  
3）多CPU系统中使用线程，提高CPU利用率  
4）改善程序结构，对一个程序进行拆分，降低程序执行难度  
5）进程之间的通信十分不方便，同一个进程中的线程可以进行数据共享

## 4. 实现多线程的方式 ##

在 java 中实现线程的方式有 2 种，一种是继承 Thread，一种是实现 Runnable 接口。

*  通过继承Thread实现:  
    继承 Thread 实现多线程，必须重写 run 方法。  
    继承语法：

class MyThread extends Thread{   
        private int ticket = 5;  
        public void run(){   
            for (int i=0;i<10;i++)  
            {   
                if(ticket > 0){   
                    System.out.println("ticket = " + ticket--);  
                }  
            }  
        }  
    }  
    
    public class ThreadDemo{   
        public static void main(String[] args){   
            new MyThread().start();  
            new MyThread().start();  
            new MyThread().start();  
        }  
    }

运行结果：

ticket = 5
    ticket = 4
    ticket = 5
    ticket = 5
    ticket = 4
    ticket = 3
    ticket = 2
    ticket = 1
    ticket = 4
    ticket = 3
    ticket = 3
    ticket = 2
    ticket = 1
    ticket = 2
    ticket = 1

每个线程单独卖了5张票，即独立的完成了买票的任务，但实际应用中，比如火车站售票，需要多个线程去共同完成任务，在本例中，即多个线程共同买5张票。

*  通过实现Runnable：  
    实现 Runnable 接口，必须重写 run 方法。  
    实现语法：

class MyThread implements Runnable{   
        private int ticket = 5;  
        public void run(){   
            for (int i=0;i<10;i++)  
            {   
                if(ticket > 0){   
                    System.out.println("ticket = " + ticket--);  
                }  
            }  
        }  
    }  
      
    public class RunnableDemo{   
        public static void main(String[] args){   
            MyThread my = new MyThread();  
            new Thread(my).start();  
            new Thread(my).start();  
            new Thread(my).start();  
        }  
    }

运行结果：

ticket = 5
    ticket = 2
    ticket = 1
    ticket = 3
    ticket = 4

在第二种方法(Runnable接口实现多线程)中，买票输出的顺序并不是54321，这是因为线程执行时会被抢占资源，所以输出结果不唯一。ticket并不是原子操作。

*  总结：  
    在第一种方法中，我们new了3个Thread对象，即三个线程分别执行三个对象中的代码，因此便是三个线程去独立地完成卖票的任务；而在第二种方法中，我们同样也new了3个Thread对象，但只有一个Runnable对象，3个Thread对象共享这个Runnable对象中的代码，因此，便会出现3个线程共同完成卖票任务的结果。如果我们new出3个Runnable对象，作为参数分别传入

## 5. 两种实现多线程方法的区别 ##

*  区别一：  
    Runnable是使用实现接口的方式来实现多线程的，Thread是通过继承的方式来实现多线程的  
    Runnable实现接口的方式更好，推荐使用，主要原因是因为实现接口的方式有利于解耦，方便代码的维护工作
 *  区别二：  
    Java只支持“接口”的多继承,不支持“类“”的多继承；而继承在java中具有单根性,子类只能继承一个父类，一句话就是单继承多实现
 *  区别三：  
    Runnable增强程序的健壮性，代码能够被多个线程共享，代码与数据是独立的
 *  区别四：  
    Runnable适合多个相同程序的线程区处理同一资源的情况

## 6. 多线程的同步（线程锁机制） ##

*  原子性操作概念：  
    如果希望一系列操作(在代码中可以认为是很多句语句)，要么都执行，要么都不执行，我们把这种操作叫做原子性操作。
 *  同步方式  
    （1）、通过synchronized关键字同步对象的方式实现（synchronized（同步对象）\{ // 需要同步的代码 \}）

public class SynchronizedDemo implements Runnable { 
        private String name;
        static Integer count = 20;
        public String getName() { 
            return name;
        }
        public void setName(String name) { 
            this.name = name;
        }
        public static Integer getCount() { 
            return count;
        }
        public static void setCount(Integer count) { 
            SynchronizedDemo.count = count;
        }
        public SynchronizedDemo() { 
        }
        public SynchronizedDemo(String name) { 
            this.name = name;
        }
    
        @Override
        public void run() { 
            while (count > 0) { 
                try { 
                    Thread.sleep(100);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                // synchronized关键字里面必须具备唯一性
                // 这里由于是对同一个对象开启多线程，所以this是唯一的
                synchronized (this) { 
                    if (count > 0) { 
                        count--;
                        System.out.println(Thread.currentThread() + " 开始吃苹果, 还剩" + count + "个苹果");
                    }
                }
            }
        }
    }
    
    public Test { 
        public static void main(String[] args) { 
            SynchronizedDemo sd = new SynchronizedDemo();
            new Thread(sd, "光头强").start();
            new Thread(sd, "熊大").start();
            new Thread(sd, "熊二").start();
    
        }
    }

运行结果：

"C:\Program Files\Java\jdk-11.0.9\bin\java.exe"
    Thread[光头强,5,main] 开始吃苹果, 还剩4个苹果
    Thread[熊二,5,main] 开始吃苹果, 还剩3个苹果
    Thread[熊大,5,main] 开始吃苹果, 还剩2个苹果
    Thread[熊大,5,main] 开始吃苹果, 还剩1个苹果
    Thread[熊二,5,main] 开始吃苹果, 还剩0个苹果

*  通过同步方法实现（synchronized 方法返回类型方法名（参数列表）\{// 其他代码\}）

public class SynchronizedDemo implements Runnable { 
        private String name;
        static Integer count = 5;
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public static Integer getCount() { 
            return count;
        }
    
        public static void setCount(Integer count) { 
            SynchronizedDemo.count = count;
        }
    
        public SynchronizedDemo() { 
        }
    
        public SynchronizedDemo(String name) { 
            this.name = name;
        }
    
        @Override
        public synchronized void run() { 
            while (count > 0) { 
                try { 
                    Thread.sleep(100);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                if (count > 0) { 
                    count--;
                    System.out.println(Thread.currentThread() + " 开始吃苹果, 还剩" + count + "个苹果");
                }
            }
        }
    }
    
    public Test { 
        public static void main(String[] args) { 
            SynchronizedDemo sd = new SynchronizedDemo();
            new Thread(sd, "光头强").start();
            new Thread(sd, "熊大").start();
            new Thread(sd, "熊二").start();
    
        }
    }

运行结果：

## 7、多线程常用方法 ##

（1）wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

（2）sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

（3）notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。

（4）Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

## 8、多线程综合案例 ##

[综合案例代码][Link 1]

# 总结 #

以上就是对多线程的总结了，代码仅供参考，欢迎讨论交流。

[Link 1]: https://blog.csdn.net/zzvar/article/details/115869699