java复习笔记--多线程

客官°小女子只卖身不卖艺 2021-05-16 20:37 511阅读 0赞

### java多线程 ###

*  进程和线程
 *  创建线程
 *   *  继承Thread类
     *  实现Runnable接口
     *  线程中方法
     *  设置和获取线程名称
     *  线程优先级
     *   *  线程调度
         *  优先级相关方法
     *  线程控制
     *   *  sleep方法
     *  join 方法
     *  setDaemon方法
     *  线程的生命周期
     *  线程同步
     *  同步代码块解决数据安全问题
     *   *   *  同步的好处和弊端
         *  同步方法解决数据安全问题
         *  线程安全的类
         *  Lock锁
         *   *  ReentrantLock构造方法
         *  Object类的等待和唤醒方法

虽然感觉平时也没有用到多线程，大多数都是单线程走到底，但是感觉多线程还是很重要的，所以整理一些笔记

# 进程和线程 #

进程：是正在运行的程序  
是系统进行资源分配和调用的独立单位  
每一个进程都有它自己的内存空间和系统资源

线程：是进程中的单个顺序控制流，是一条执行路径  
单线程：一个进程如果只有一条执行路径，则称为单线程程序  
多线程：一个进程如果有多条执行路径，则称为多线程程序

# 创建线程 #

创建线程有两种方法，  
实现多线程方式一：继承Thread类  
实现多线程方式二：实现Runnable接口  
但是一般都会选择实现Runnable接口，相比继承Thread类，实现Runnable接口的好处

避免了Java单继承的局限性  
适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想

## 继承Thread类 ##

实现步骤

定义一个类MyThread继承Thread类
    在MyThread类中重写run()方法
    创建MyThread类的对象
    启动线程

public class Mythread extends Thread{ 
        @Override
        public void run() { 
           for(int i=0;i<100;i++)
           { 
               System.out.println(i);
           }
        }
    }
    
    public class threadtest
    { 
        public static void main(String[] args) { 
             Mythread t1 = new Mythread();
             Mythread t2=new Mythread();
            //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
             t1.start();
             t2.start();
        }
    }

## 实现Runnable接口 ##

实现步骤

定义一个类MyRunnable实现Runnable接口
    在MyRunnable类中重写run()方法
    创建MyRunnable类的对象
    创建Thread类的对象，把MyRunnable对象作为构造方法的参数
    启动线程

public class Mythread implements Runnable{ 
        @Override
        public void run() { 
           for(int i=0;i<100;i++)
           { 
               System.out.println(i);
           }
        }
    }
    
    public class threadtest
    { 
        public static void main(String[] args) { 
             Mythread mythread = new Mythread();
    
             Thread t1=new Thread(mythread);
            Thread t2=new Thread(mythread);
    
            t1.start();
            t2.start();
        }
    }

## 线程中方法 ##

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void run()</td> 
   <td>在线程开启后，此方法将被调用执行</td> 
  </tr> 
  <tr> 
   <td>void start()</td> 
   <td>使此线程开始执行，Java虚拟机会调用run方法()</td> 
  </tr> 
 </tbody> 
</table>

为什么要重写run()方法？

因为run()是用来封装被线程执行的代码

run()方法和start()方法的区别？

run()：封装线程执行的代码，直接调用，相当于普通方法的调用
    start()：启动线程；然后由JVM调用此线程的run()方法

## 设置和获取线程名称 ##

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void setName(String name)</td> 
   <td>将此线程的名称更改为等于参数name</td> 
  </tr> 
  <tr> 
   <td>String getName()</td> 
   <td>返回此线程的名称</td> 
  </tr> 
  <tr> 
   <td>static Thread currentThread()</td> 
   <td>返回对当前正在执行的线程对象的引用</td> 
  </tr> 
 </tbody> 
</table>

Thread currentThread()是静态方法可以直接调用

除了用setName(String name) 设置线程名称还可以直接创建的时候就给名字Thread(String name)

public class Mythread extends Thread{ 
        public Mythread()
        { 
    
        }
    
        public Mythread(String name) { 
            super(name);
        }
    
        @Override
        public void run() { 
           for(int i=0;i<100;i++)
           { 
               System.out.println(getName()+" : "+i);
           }
        }
    }
    
    public class threadtest
    { 
        public static void main(String[] args) { 
    // Mythread t1 = new Mythread();
    // Mythread t2=new Mythread();
            //void setName(String name)：将此线程的名称更改为等于参数 name
    // t1.setName("dyk");
    // t2.setName("cb");
            Mythread t1 = new Mythread("dyk");
            Mythread t2=new Mythread("lfw");
            //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
            t1.start();
            t2.start();
            //static Thread currentThread() 返回对当前正在执行的线程对象的引用
    
            System.out.println(Thread.currentThread().getName());
        }
    }

注意如果要在创建时就起名字必须手动给出带参构造方法

如果是实现Runnable

**Thread构造方法**

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Thread(Runnable target)</td> 
   <td>分配一个新的Thread对象</td> 
  </tr> 
  <tr> 
   <td>Thread(Runnable target, String name)</td> 
   <td>分配一个新的Thread对象</td> 
  </tr> 
 </tbody> 
</table>

注意因为实现Runnable没有继承thread类所以不能直接使用getName方法，所以要调用currentThread()这个静态方法，再调用getName

## 线程优先级 ##

### 线程调度 ###

**两种调度方式**  
分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片

抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些

Java使用的是抢占式调度模型

**随机性**  
假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

注意优先级高的不一定优先执行，只是抢到cpu资源的可能性大一些，也就是优先级低的也有可能在优先级高的前面执行

java里面优先级的范围是1到10，默认的优先级是5

### 优先级相关方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>final int getPriority()</td> 
   <td>返回此线程的优先级</td> 
  </tr> 
  <tr> 
   <td>final void setPriority(intnewPriority)</td> 
   <td>更改此线程的优先级 线程默认优先级是5；线程优级的范围是：1-10</td> 
  </tr> 
 </tbody> 
</table>

public class threadtest
    { 
        public static void main(String[] args) { 
            Mythread mythread = new Mythread();
    
            Thread t1=new Thread(mythread,"dyk");
            Thread t2=new Thread(mythread,"lfw");
    
            System.out.println(t1.getPriority()); //5
            System.out.println(t2.getPriority());//5
            //public final void setPriority(int newPriority)：更改此线程的优先级
            // tp1.setPriority(10000); //IllegalArgumentException
    
            //设置正确的优先级
            t1.setPriority(10);
            t2.setPriority(1);
    
            System.out.println(t1.getPriority()); //10
            System.out.println(t2.getPriority()); //1
    
            t1.start();
            t2.start();
    
            System.out.println(Thread.MAX_PRIORITY); //10
            System.out.println(Thread.MIN_PRIORITY); //1
            System.out.println(Thread.NORM_PRIORITY); //5
        }
    }

## 线程控制 ##

相关方法

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>static void sleep(longmillis)</td> 
   <td>使当前正在执行的线程停留（暂停执行）指定的毫秒数</td> 
  </tr> 
  <tr> 
   <td>void join()</td> 
   <td>等待这个线程死亡，其他线程才能执行</td> 
  </tr> 
  <tr> 
   <td>void setDaemon(booleanon)</td> 
   <td>将此线程标记为守护线程，当运行的线程都是守护线时，Java虚拟机将退出</td> 
  </tr> 
 </tbody> 
</table>

### sleep方法 ###

public class Mythread implements Runnable{ 
        @Override
        public void run() { 
            for(int i=0;i<100;i++)
            { 
                try { 
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName()+" : "+i);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
    
            }
        }
    }

注意单位是毫秒而不是秒

## join 方法 ##

join方法可以用这个形象的例子来理解，例如我现在有三个线程，名字分别为康熙，八阿哥，和四阿哥，他们3争夺皇位，但是康熙是他们爸爸啊，所以，只有康熙驾崩了，八阿哥和四阿哥才能争夺皇位，所以就给康熙添加join方法，只有等康熙这个线程结束了，八阿哥和四阿哥这两个线程才会开始

public class Mythread implements Runnable{ 
        @Override
        public void run() { 
            for (int i = 0; i < 100; i++) { 
                System.out.println(Thread.currentThread().getName() + " : " + i);
                
            }
        }
    }
    
    
    public class threadtest
    { 
        public static void main(String[] args) { 
            Mythread mythread = new Mythread();
    
            Thread t1=new Thread(mythread,"康熙");
            Thread t2=new Thread(mythread,"四阿哥");
            Thread t3=new Thread(mythread,"八阿哥");
            t1.start();
            try { 
                t1.join();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            t2.start();
            t3.start();
    
        }
    }

注意join方法只有，先start启动后在添加才有效果

## setDaemon方法 ##

关于这个方法也举一个形象的例子，这里有三个线程，刘备(主线程)，关羽，张飞，把关羽和张飞设置为守护线程，当刘备死了，也就是主进程结束了，那么关羽和张飞也会马上死亡，因为当年他们桃园三结义的时候，说了不求同年同月同日生，但求同年同月同日死。

public class Mythread implements Runnable{ 
        @Override
        public void run() { 
            for (int i = 0; i < 100; i++) { 
                System.out.println(Thread.currentThread().getName() + " : " + i);
    
            }
        }
    }
    
    
    public class threadtest
    { 
        public static void main(String[] args) { 
            Mythread mythread = new Mythread();
    
            Thread t1=new Thread(mythread,"关羽");
            Thread t2=new Thread(mythread,"张飞");
    
            //设置主线程为刘备
            Thread.currentThread().setName("刘备");
    
            //设置守护线程
            t1.setDaemon(true);
            t2.setDaemon(true);
      		
      		t1.start();
      		t2.start();
    
            for(int i=0; i<10; i++) { 
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
    
    
        }
    }

## 线程的生命周期 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0ODY2MTUz_size_16_color_FFFFFF_t_70_pic_center]

## 线程同步 ##

买票的例子

public class sellticks implements Runnable{ 
        private  static int tickets=100;
        @Override
        public void run() { 
            while (true){ 
    
                if(tickets>0){ 
                    try { 
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                        tickets--;
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
    
                }
            }
        }
    }
    
    
    
    public class sellsticks_test { 
        public static void main(String[] args) { 
    
             sellticks st = new sellticks();
    
             Thread th1 = new Thread(st,"窗口一");
             Thread th2 = new Thread(st,"窗口二");
             Thread th3 = new Thread(st,"窗口三");
    
             th1.start();
             th2.start();
             th3.start();
        }
    }

卖票出现了问题  
相同的票出现了多次  
出现了负数的票

问题产生原因  
线程执行的随机性导致的

## 同步代码块解决数据安全问题 ##

安全问题出现的条件

是多线程环境
    有共享数据
    有多条语句操作共享数据

把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可  
Java提供了同步代码块的方式来解决

同步代码块格式：

synchronized(任意对象) { 
    多条语句操作共享数据的代码
    }

synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

#### 同步的好处和弊端 ####

好处：解决了多线程的数据安全问题  
弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

public class sellticks implements Runnable{ 
        private  static int tickets=100;
        private Object obj=new Object();
        @Override
        public void run() { 
            while (true){ 
             synchronized (obj){ 
                 if(tickets>0){ 
                     try { 
                         Thread.sleep(200);
                         System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                         tickets--;
                     } catch (InterruptedException e) { 
                         e.printStackTrace();
                     }
    
                 }
    
             }
    
            }
        }
    }
    
    
    public class sellsticks_test { 
        public static void main(String[] args) { 
    
             sellticks st = new sellticks();
    
             Thread th1 = new Thread(st,"窗口一");
             Thread th2 = new Thread(st,"窗口二");
             Thread th3 = new Thread(st,"窗口三");
    
             th1.start();
             th2.start();
             th3.start();
        }
    }

### 同步方法解决数据安全问题 ###

同步方法的格式  
同步方法：就是把synchronized关键字加到方法上

修饰符 synchronized 返回值类型 方法名(方法参数) { 
    方法体；
    }

同步方法的锁对象是什么呢?  
this

静态同步方法  
同步静态方法：就是把synchronized关键字加到静态方法上

修饰符 static synchronized 返回值类型 方法名(方法参数) { 
    方法体；
    }

同步静态方法的锁对象是什么呢?  
类名.class

public class SellTicket implements Runnable { 
        private static int tickets = 100;
    
        private int x = 0;
        @Override
        public void run() { 
            while (true) { 
                sellTicket()；
            }
        }
    // 同步方法
    // private synchronized void sellTicket() { 
    // if (tickets > 0) { 
    // try { 
    // Thread.sleep(100);
    // } catch (InterruptedException e) { 
    // e.printStackTrace();
    // }
    // System.out.println(Thread.currentThread().getName() + "正在出售第" +
        tickets + "张票");
        // tickets--;
    // }
    // }
    // 静态同步方法
        private static synchronized void sellTicket() { 
            if (tickets > 0) { 
                try { 
                    Thread.sleep(100);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在出售第" +
                        tickets + "张票");
                tickets--;
            }
        }
    }
    public class SellTicketDemo { 
        public static void main(String[] args) { 
            SellTicket st = new SellTicket();
            Thread t1 = new Thread(st, "窗口1");
            Thread t2 = new Thread(st, "窗口2");
            Thread t3 = new Thread(st, "窗口3");
            t1.start();
            t2.start();
            t3.start();
        }
    }

### 线程安全的类 ###

**StringBuffer**  
线程安全，可变的字符序列  
从版本JDK 5开始，被StringBuilder 替代。 通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步

**Vector**  
从Java 2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Vector被同步。 如果不需要线程安全的实现，建议使用ArrayList代替Vector

**Hashtable**  
该类实现了一个哈希表，它将键映射到值。 任何非null对象都可以用作键或者值从Java 2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Hashtable被同步。 如果不需要线程安全的实现，建议使用HashMap代替Hashtable

其中vector和hashtable也不怎么用了可以用collections里面的方法获得同步的集合

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>synchronizedList(List list)</td> 
   <td>返回由指定列表支持的同步（线程安全）列表</td> 
  </tr> 
  <tr> 
   <td>synchronizedMap(Map&lt;K,V&gt; m)</td> 
   <td>返回由指定map支持的同步（线程安全）映射。</td> 
  </tr> 
  <tr> 
   <td>synchronizedSet(Set s)</td> 
   <td>返回由指定集合支持的同步（线程安全）集。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

### Lock锁 ###

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了  
锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock  
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

#### ReentrantLock构造方法 ####

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ReentrantLock()</td> 
   <td>创建一个ReentrantLock的实例</td> 
  </tr> 
 </tbody> 
</table>

加锁解锁方法

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void lock()</td> 
   <td>获得锁</td> 
  </tr> 
  <tr> 
   <td>void unlock()</td> 
   <td>释放锁</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class sellticks implements Runnable{ 
        private  static int tickets=100;
       private Lock lock=new ReentrantLock();
        @Override
        public void run() { 
            while (true){ 
             try { 
                 lock.lock();
                 if(tickets>0) { 
    
                     Thread.sleep(200);
                     System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                     tickets--;
                 }
                     } catch (InterruptedException e) { 
                         e.printStackTrace();
                     }
                   finally { 
    
                   lock.unlock();
             }
    
    
    
             }
    
            }
    
    }
    
    
    public class sellsticks_test { 
        public static void main(String[] args) { 
    
             sellticks st = new sellticks();
    
             Thread th1 = new Thread(st,"窗口一");
             Thread th2 = new Thread(st,"窗口二");
             Thread th3 = new Thread(st,"窗口三");
    
             th1.start();
             th2.start();
             th3.start();
        }
    }

### Object类的等待和唤醒方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void wait()</td> 
   <td>导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法</td> 
  </tr> 
  <tr> 
   <td>void notify()</td> 
   <td>唤醒正在等待对象监视器的单个线程</td> 
  </tr> 
  <tr> 
   <td>void notifyAll()</td> 
   <td>唤醒正在等待对象监视器的所有线程</td> 
  </tr> 
 </tbody> 
</table>

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0ODY2MTUz_size_16_color_FFFFFF_t_70_pic_center]: /images/20210516/20110908e6a74d22b4fce1da2d4831c2.png