线程（学习线程的案例和知识点，有兴趣可以微信搜索狂神说公众号）

最新推荐文章于 2022-02-08 21:40:16 发布
最新推荐文章于 2022-02-08 21:40:16 发布
阅读量214 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45054991/article/details/119100050
版权

线程与进程（Thread&&process）

    • 进程是程序执行一次的过程，是动态的概念，是系统资源分配的单位。
    • 程序是指令和数据的有序集合，其本身没有运行的含义，是一个静态的概念。
    • 通常情况下，一个进程中有多个线程，当然一个进程至少有一个线程，不然没有存在的意义，线程是CPU调度和执行的单位。
    • 注意：很多多线程是模拟出来的，真正的多线程是多个CPU，多核，如服务器。如果是模拟出来的多线程，即在一个CPU下，同一时间点，CPU只能执行一行代码，因为切换的快，所以才会有同步的错觉。

  • 线程简介

  • 多任务：

  • 多线程：（生活，游戏，编程）

  • 普通方法调用和多线程

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jifbd6y7-1627258022452)(C:\Users\29195\AppData\Roaming\Typora\typora-user-images\image-20210724120917204.png)]

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8nyFyOuD-1627258022456)(C:\Users\29195\AppData\Roaming\Typora\typora-user-images\image-20210724120947969.png)]

  • 程序.进程.线程

    程序静态概念

    进程动态概念

    线程之间互不影响（进程相当于线程的保护伞）

    本章核心概念

    • 线程是独立的执行路径
    • 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
    • main()称之为主线程，系统的入口，用于执行整个程序；
    • 在一个进程中，如果开辟了多个线程，线程的运行调度器（CPU）安排调度，调度器是于操作系统紧密相关的，先后顺序是不能人为的干预。
    • 对同一份资源操作时会存在资源抢夺的问题，需要加入并发控制；
    • 线程会带来额外开销，如CPU调度时间，并发控制开销。
    • 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

    线程的创建

    三种创建方式

    • Thread class ：继承 thread类（重点）

    • 定义线程继承类Thread类

    • 重写run()方法，编写线程执行体

    • 创建线程对象，调用Start（）方法启动线程

  • 案例

    package com.kuang.demo1;
/*总结：注意，线程开启不一定立即执行，由CPU调度执行
*/
public class TestThread1 extends Thread{
    @Override
    public void run(){
        //run方法线程体
        for(int i=0;i<20;i++){
            System.out.println("wwwwww");
        }
    }

    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread1 testThread1 =new TestThread1();
        //调用start()方法启动线程
        testThread1.start();
        //调用run（）方法
        //testThread1.run();
        for(int i=0;i<2000;i++){
            System.out.println("我在学习多线程"+i);
        }
    }
}


       package com.kuang.demo1;
   
   import com.sun.jmx.snmp.SnmpUnknownAccContrModelException;
   import com.sun.org.apache.xalan.internal.xsltc.dom.CurrentNodeListFilter;
   import com.sun.org.apache.xpath.internal.objects.XString;
   import org.apache.commons.io.FileUtils;
   
   import java.io.File;
   import java.io.IOException;
   import java.net.URL;
   
   public class TestThread2 extends Thread{
       private String url;//网络图片传输
       private String name;//保存的文件名
       public TestThread2(String url,String name ){
           this.name=name;
           this.url=url;
       }
       //下载器
       //下载图片线程执行体
       @Override
       public void run(){
           WebDownloader webDownloader=new WebDownloader();
           webDownloader.downloader(url,name);
           System.out.println("下载了文件名为："+name);
       }
   
       class WebDownloader {
           public  void downloader(String url, String name) {
           try {
               FileUtils.copyURLToFile(new URL(url), new File(name));
           } catch (IOException e) {
               e.printStackTrace();
               System.out.println("IO异常，downladder方法出现问题");
           }
   
       }
   
       }
   
       public static void main(String[] args) {
   
           TestThread2 t1=new TestThread2("http://img.1ppt.com/uploads/allimg/2107/1-210H1152G90-L.jpg","2.jpg");
           TestThread2 t2=new TestThread2("http://img.1ppt.com/uploads/allimg/2107/1-210G51625420-L.jpg","1.jpg");
           TestThread2 t3=new TestThread2("http://img.1ppt.com/uploads/allimg/2107/1-210G51050140-L.jpg","3.jpg");
           
           t1.start();
           t2.start();
           t3.start();
       }
   }

  • Runnable 接口 ：实现Runnable接口（重点）

    • 定义一个MyRunnable类实现Runnable接口

    • 实现run（）方法，编写线程执行体

    • 创建线程对象，调佣Start（）方法启动线程

    • 推荐使用Runnable，主要是Java

  • 案例

      package com.kuang.demo1;
  //创建线程方式2：实现Runnable接口，重写run（）方法，执行线程需要丢入Runnable接口实现类，调用start方法
  public class TestThread3 implements Runnable{
  
  
  
      @Override
      public void run(){
          //run方法线程体
          for(int i=0;i<20;i++){
              System.out.println("wwwwww");
          }
      }
  
      public static void main(String[] args) {
          //main线程，主线程
          //创建一个Runnable接口的实现类对象
          TestThread3 testThread3 =new TestThread3();
          //调用start()方法启动线程
          new Thread (testThread3).start();
          for(int i=0;i<2000;i++){
              System.out.println("我在学习多线程"+i);
          }
      }
  }

    案例二：

      package com.kuang.demo1;
  
  import com.sun.jmx.snmp.SnmpUnknownAccContrModelException;
  import com.sun.org.apache.xalan.internal.xsltc.dom.CurrentNodeListFilter;
  import com.sun.org.apache.xpath.internal.objects.XString;
  import org.apache.commons.io.FileUtils;
  
  import java.io.File;
  import java.io.IOException;
  import java.net.URL;
  
  public class TestThread2 implements Runnable{
      private String url;//网络图片传输
      private String name;//保存的文件名
      public TestThread2(String url,String name ){
          this.name=name;
          this.url=url;
      }
      //下载器
      //下载图片线程执行体
      @Override
      public void run(){
          WebDownloader webDownloader=new WebDownloader();
          webDownloader.downloader(url,name);
          System.out.println("下载了文件名为："+name);
      }
  
      class WebDownloader {
          public  void downloader(String url, String name) {
          try {
              FileUtils.copyURLToFile(new URL(url), new File(name));
          } catch (IOException e) {
              e.printStackTrace();
              System.out.println("IO异常，downladder方法出现问题");
          }
  
      }
  
      }
  
      public static void main(String[] args) {
  
          TestThread2 t1=new TestThread2("http://img.1ppt.com/uploads/allimg/2107/1-210H1152G90-L.jpg","2.jpg");
          TestThread2 t2=new TestThread2("http://img.1ppt.com/uploads/allimg/2107/1-210G51625420-L.jpg","1.jpg");
          TestThread2 t3=new TestThread2("http://img.1ppt.com/uploads/allimg/2107/1-210G51050140-L.jpg","3.jpg");
  
          new Thread(t1).start();
          new Thread(t2).start();
          new Thread(t3).start();
      }
  }

    小结：

    • 继承Thread类

      • 子类继承Thread类具备多线程能力
      • 启动线程：子类对象.start（）（ 例如：testThread1.start()）
      • 不建议使用：避免oop单继承局限性

    • 实现Runnable 接口

      • 实现接口Runnable具有多线程的能力

      • 启动线程：传入目标对象+Thread对象.start()（例如：new Thread(t1).start()）

      • 推荐使用：避免但继承的局限性，灵活方便，方便同一个对象被多个线程使用

      • Callable接口：实现Callable接口（了解）

        • 实现Callable 接口，需要返回值类型

        • 重写call方法，需要抛出异常

        • 创建目标对象

        • 创建执行服务：ExecutorService ser=Executoes.newFixedThreadPool(1);

        • 提交执行：Futureresult1=ser.submit(t1);

        • 获取结果：Boolean r1=result1.get()

        • 关闭服务：ser.shutdownNow();

    • 案例：

       package com.kuang.demo1;
 
 import org.apache.commons.io.FileUtils;
 
 import java.io.File;
 import java.io.IOException;
 import java.net.URL;
 import java.util.concurrent.*;
 
 public class Textcallable implements Callable<Boolean> {
 
 private String url;//网络图片传输
 private String name;//保存的文件名
 public Textcallable(String url,String name ){
         this.name=name;
         this.url=url;
         }
 //下载器
 //下载图片线程执行块
     @Override
     public Boolean call()  {
         WebDownloader webDownloader=new WebDownloader();
         webDownloader.downloader(url,name);
         System.out.println("下载了文件名为："+name);
         return true;
     }
 
     class WebDownloader {
     public  void downloader(String url, String name) {
         try {
             FileUtils.copyURLToFile(new URL(url), new File(name));
         } catch (IOException e) {
             e.printStackTrace();
             System.out.println("IO异常，downladder方法出现问题");
         }
 
     }
 
 }
 
     public static void main(String[] args) throws ExecutionException,InterruptedException {
 
         Textcallable t1=new Textcallable("http://img.1ppt.com/uploads/allimg/2107/1-210H1152G90-L.jpg","2.jpg");
         Textcallable t2=new Textcallable("http://img.1ppt.com/uploads/allimg/2107/1-210G51625420-L.jpg","1.jpg");
         Textcallable t3=new Textcallable("http://img.1ppt.com/uploads/allimg/2107/1-210G51050140-L.jpg","3.jpg");
 
 //        - 创建执行服务：ExecutorService ser=Executoes.newFixedThreadPool(1);
         ExecutorService ser= Executors.newFixedThreadPool(3);
 //        - 提交执行：Future<Boolean>result1=ser.submit(t1);
         Future<Boolean> result1=ser.submit(t1);
         Future<Boolean> result2=ser.submit(t2);
         Future<Boolean> result3=ser.submit(t3);
 //        - 获取结果：Boolean r1=result1.get()
         Boolean r1=result1.get();
         Boolean r2=result1.get();
         Boolean r3=result1.get();
         System.out.println(r1);
         System.out.println(r2);
         System.out.println(r3);
         ser.shutdownNow();
 //                - 关闭服务：ser.shutdownNow();
     }
 }

    静态代理

    /*
总结：真实对象和代理对象都要实现同一个接口
代理对象要代理真实角色
好处：代理对象可以做很多真实对象做不了的事情
真实对象专注做自己的事情
*/
public class StacticProsy {
    public static void main(String[] args) {
        //你要结婚
        You you =new You();//你要结婚
        WeddingCompary weddingCompary=new WeddingCompary(you);
        weddingCompary.HappyMarry();
    }
}
    interface Marry {
        void HappyMarry();
    }
//真实角色你去结婚
    class You implements Marry {
        @Override
        public void HappyMarry() {
            System.out.println("王明结婚了，超开心");
        }
    }
//代理对象，帮助你结婚
    class WeddingCompary implements Marry {
        //代理谁--》真实目标角色
        private Marry target;
        public WeddingCompary(Marry target) {
            this.target = target;
        }

        @Override
        public void HappyMarry() {
            before();
            this.target.HappyMarry();//这就是真实对象
            after();
        }

        private void before() {
            System.out.println("结婚之前，布置现场");
        }

        private void after() {
            System.out.println("结婚之后，收尾款");
        }
    }

    Lamdaa表达式

    • 入希腊字母表中排序第十一位的字母，英语名称Lambd

    • 避免匿名内部类定义过多

    • 其实质属于函数式编程的概念

    • (params) -> expression表达式

    • (params)-> statement语句

    • (params)->{ statements}

    • new Thread ((->System.out.printIn(“多线程学习。。。。")) .start();

    • 为什么要使用lambda表达式

    • 避免匿名内部类定义过多

    • 可以让你的代码看起来很简洁

    • 去掉了一堆没有意义的代码，只留下核心的逻辑。

    • 也许你会说，我看了Lambda表达式，不但不觉得简洁，反而觉得更乱，看不懂，那是因为我们用的还不是很多。

    • 理解Functional interface(函数式接口）学习java8 lambda表达式的关键所在。

    • 函数式接口的定义：

      • 任何借口，如果质包含唯一一个抽象方法，那么他就是一个函数式接口。

      • public interface Runnable{

        ​ public abstract void run（）；

        }

  • 对于函数式接口，我们可以通过lambda表达式来创建改接口的对象。案例一：

案例：

 public class Testlambda {
     //3静态内部类
     static class Like implements Ilike {
         @Override
         public void lambda() {
             System.out.println("I love you too");
         }
     }
 
     public static void main(String[] args) {
         Ilike like = new Like();
         like.lambda();
         like = new Like();
         //4局部内部类
         class Like3 implements Ilike {
             @Override
             public void lambda() {
                 System.out.println("I love you 3");
             }
         }
         //5.匿名内部类,没有类的名字，必须借助接口或者父类
         like = new Ilike() {
 
             @Override
             public void lambda() {
                 System.out.println("I love you 4");
             }
         };
         like.lambda();
         //6.用lambda简化
         like = () -> {
             System.out.println("I love you 5");
 
         };
         like.lambda();
     }
 }
 //定义一个函数式接口
 interface Ilike{
     void lambda();
 }
 //实现类
 class Like implements Ilike{
 
     @Override
     public void lambda() {
         System.out.println("I love you");
     }
 }

案例二：

package com.kuang.demo1;

public class TestLambda1 {
//    static class love implements Ilove{
//
//        @Override
//        public void love(int a) {
//            System.out.println("qqqqq");
//        }
//    }
    public static void main(String[] args) {
//        class Love implements Ilove{
//
//            @Override
//            public void love(int a) {
//
//            }
//        }
//        Ilove love=new Ilove(){
//
//            @Override
//            public void love(int a) {
//
//            }
//        };
//        //Ilove love =new Love();
 //      love.love(3);
        //lambda简化
       Ilove love=(int a)->{
           System.out.println("llllll"+a);
       };

        //简化参数类型
       love=(a)->{
           System.out.println("2222"+a);
       };
        love.love(520);
        //简化括号
        love=a->{
            System.out.println("3333"+a);
        };
        //简化三去掉花括号
        love=a-> System.out.println("aaaaa"+a);
        love.love(520);
   }
    /**总结：
     *  lambda表达式只能有一行代码的情况下可以简化成一行，如果有多行，那么就用代码快包裹
     *  前提是接口为函数式接口
     *  多个参数也可以省略掉参数类型，要去掉就都去掉，必须加上括号
     */


}
interface Ilove{
    void love(int a);
}

线程状态

在这里插入图片描述

停止线程

  • 不推荐使用JDK提供的stop().destroy()方法。【已废弃】

  • 推荐线程自己停止下来

  • 建议使用一个标志位进行终止变量当flag=false，则终止线程运行。

  • 案例1:

 package com.kuang.demo1;
 
 /**
  * 测试stop
  * 1.建议线程正常停止---》利用次数，不建议死循环
  * 2.建议使用标志位----》设置一个标志位
  * 3.不要使用stop或者destroy等过时或者3Dk不建议使用的方法
  */
 public class TestStop implements Runnable{
     private boolean flag=true;
 //设置一个志位
     @Override
     public void run() {
         int i=0;
         while(flag){
             System.out.println("run......Thread"+i++);
         }
     }
 
     public static void main(String[] args) {
     TestStop testStop=new TestStop();
     new Thread(testStop).start();
     for(int i=0;i<1000;i++){
         System.out.println("main"+i);
         if (i==900){
             testStop.stop();
             System.out.println("线程停止了");
         }
 
     }
 
     }
 
     private void stop() {
         this.flag=false;
     }
 }

线程休眠

  • sleep(时间)指定当前线程阻塞的毫秒数;

  • sleep存在异常InterruptedException;

  • sleep时间达到后线程进入就绪状态;

  • sleep可以模拟网络延时，倒计时等。

  • 每一个对象都有一个锁，sleep不会释放锁;

案例2：（时间延迟）

 package com.kuang.demo1;
 //模拟网络延时：放大问题的发生性
 public class TestSleep implements Runnable{
     private int ticketNums=10;
     @Override
     public void run() {
         while(true){
             if(ticketNums<=0){
                 break;
             }
 
             //模拟延时
 
             try {
                 Thread.sleep(200);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             System.out.println(Thread.currentThread().getName()+"---》拿到了第"+ticketNums--+"票");
         }
     }
 
     public static void main(String[] args) {
         TestSleep ticket=new TestSleep();
         new Thread(ticket,"小红").start();
         new Thread(ticket,"小明").start();
         new Thread(ticket,"校长").start();
     }
 }
 
 ```

 案例2：（倒计时）

 ```
 
 ```

 ```java
 package com.kuang.demo1;
 
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.SimpleTimeZone;
 
 public class Testsleep2 {
     //模拟倒计时
     public static void tenDown(){
         int num=10;
     while(true){
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         if(num<=0){
             break;
         }
         System.out.println(num--);
     }
     }
 
     public static void main(String[] args) {
         tenDown();
         Date starttime=new Date(System.currentTimeMillis());
     while(true){
         try {
             Thread.sleep(1000);
             System.out.println(new SimpleDateFormat("HH:mm:ss").format(starttime));
             starttime =new Date(System.currentTimeMillis());
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 
     }
 }

线程礼让

  • 礼让线程，让当前正在执行的线程暂停，但本阻塞

  • 将线程从运行状态转为就绪状态

  • 让cpu重新调度，礼让不一定成功!看CPU心情

  • 案例3：

 package com.kuang.demo1;
 //测试礼让线程
 //礼让不一定成功,看cpu心情
 import com.sun.scenario.effect.impl.sw.java.JSWBlend_SRC_OUTPeer;
 
 public class TestYield {
     public static void main(String[] args) {
         Myyield myyield=new Myyield();
         new Thread(myyield,"a").start();
         new Thread(myyield).start();
     }
 }
 
 class Myyield implements  Runnable{
 
     @Override
     public void run() {
         System.out.println(Thread.currentThread().getName()+"线程开始执行");
         Thread.yield();//礼让
         System.out.println(Thread.currentThread().getName()+"线程终止执行");
     }
 }

join

  • Join合并线程，待此线程执行完成后，再执行其他线程,几其他线程阻塞

  • 可以想象成插队

  • 案例4：

      package com.kuang.demo1;
  //测试join
  public class TestJoin implements Runnable {
  
      @Override
      public void run() {
          for(int i=0;i<1000;i++){
              System.out.println("线程vip来了");
          }
      }
  
      public static void main(String[] args) throws InterruptedException {
          TestJoin testJoin=new TestJoin();
          Thread thread=new Thread(testJoin);
          thread.start();
      for (int i=0;i<20;i++){
          if(i==200){
              thread.join();
          }
          System.out.println("main"+i);
      }
      }
  }

    线程状态观测

    Thread.State

    • 线程状态。线程可以处于以下状态之一:

    • . NEw

      尚未启动的线程处于此状态。

    • RUNNABLE
      在Java虚拟机中执行的线程处于此状态。

    • BLOCKED
      被阻塞等待监视器锁定的线程处于此状态。

    • wAITING
      正在等待另一个线程执行特定动作的线程处于此状

    • TIMED_WAITING
      正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。

    • . TERMINATED
      已退出的线程处于此状态。

    一个线程可以在给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。

案例5：

package com.kuang.demo1;
//观测线程状态
public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 4; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("//");

        });
        //观察状态
        Thread.State state = thread.getState();//new
        System.out.println(state);
        //观察启动
        thread.start();//启动线程
        state = thread.getState();
        System.out.println(state);//run
        while (state != Thread.State.TERMINATED)
        //只要线程不终止，就一直输出状
        {
        Thread.sleep(100);
        state = thread.getState();//更新线程状态
        System.out.println(state);//输出状态
    }
   // thread.start();
}
}

线程优先级

  • Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
  • 线程的优先级用数字表示，范围从1~10.
    • Thread.MIN_PRIORITY = 1;
    • Thread.MAX_PRIORITY = 10;
    • Thread.NORM_PRIORITY = 5;（大多数默认都是5）
  • 使用以下方式改变或获取优先级
    • getPriority() . setPriority(int xxx)
    • 优先级低只是意味着获得调度的概率低.并不是优先级低就不会被调用了.这都是看CPU的调度

案例：

package com.kuang.demo1;

import java.sql.SQLOutput;

public class TestPriorty {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
        MyPriorty myPriorty=new MyPriorty();
        Thread t1=new Thread(myPriorty);
        Thread t2=new Thread(myPriorty);
        Thread t3=new Thread(myPriorty);
        Thread t4=new Thread(myPriorty);
        Thread t5=new Thread(myPriorty);
        Thread t6=new Thread(myPriorty);
        t1.start();
        t2.setPriority(1);
        t2.start();
        t3.setPriority(4);
        t3.start();

        t6.setPriority(7);
        t6.start();
        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();
        t5.setPriority(-1);//(报错)
        t5.start();

守护（deamon）线程

  • 线程分为用户线程和守护线程

  • 虚拟机必须确保用户线程执行完毕

  • 虚拟机不用等待守护线程执行完毕gc（垃圾回收线程）

  • 如,后台记录操作日志,监控内存,垃圾回收等待…

  • 案例：

```java

package com.kuang.demo1;

public class TestDaemon {
public static void main(String[] args) {
God god = new God();
You you = new You();
Thread thread=new Thread(god);
thread.setDaemon(true);
thread.start();
new Thread(you).start();
//上帝

  }

}
//你
class You implements Runnable {

          @Override
          public void run() {
              for (int i = 0; i < 36500; i++) {
                  System.out.println("你一生都开心的活着");
              }
              System.out.println("-====goodbye! world!=======");
          }
      }
      class God implements Runnable{

          @Override
          public void run() {
              while(true){
                  System.out.println("上帝保佑你");
              }
          }
      }


### 线程同步（安全性形成条件：锁+队列）

#### 并发：同一对象被多个线程同时操作

- 处理多线程问题时**,多个线程访问同一个对象**（并发）﹐并且某些线程还想修改这个对象﹒这时候我们就需要**线程同步**﹒**线程同步其实就是一种等待机制,**多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕，下一个线程再使用
- 由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性﹐在访问时加入锁机制synchronized，当一个线程获得对象的排它锁﹐独占资源，其他线程必须等待，使用后释放锁即可.存在以下问题:
  - 一个线程持有锁会导致其他所有需要此锁的线程挂起;
  - 在多线程竞争下,加锁﹐释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
  - 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置﹐引起性能问题．

案例1

```java
package com.kuang.demo1;
//不安全的买票
//线程不安全，有负数
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station=new BuyTicket();
        new Thread(station,"苦逼的我").start();
        new Thread(station,"牛逼").start();
        new Thread(station).start();
        new Thread(station,"可恶的黄牛党").start();
    }
}
class BuyTicket implements Runnable{
//票
    private int ticketNums=10;
    boolean flag=true;
    @Override
    public void run() {
        while(flag){
            buy();
        }
        //买票
    }
    private void buy(){
        //判断是否有票
        if(ticketNums<=0){
            flag=false;
            return;
        }
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);

    }
}

案例二：（银行取钱两个人在同一账户取钱都看到账户存有100万，这就是产生不安全的原因）

package com.kuang.demo1;

public class UnsafeBank {
    public static void main(String[] args) {
        Account account=new Account(100,"结婚资金");
        Drawing you=new Drawing(account,50,"王明");
        Drawing grilFriend=new Drawing(account,100,"王明对象");
        you.start();
        grilFriend.start();
    }
}
class Account{
    int money;//余额
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
//银行
class Drawing extends Thread{
    Account account;//账户
    int drawingMoney;//取了多少钱
    int nowMoney;//现在手里多少钱

    public Drawing( Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;

    }
    //取钱
    @Override
    public void run(){
        //判断有没有钱
        if(account.money-drawingMoney<=0){
            System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
        return;
        }
        //sleep可以放大问题的放生性
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额=余额-你取的钱
        nowMoney=account.money-drawingMoney;
        System.out.println(account.name+"余额为"+account.money);
        System.out.println(this.getName()+"手里的钱"+nowMoney);
    }
}

​ 案例三：

package com.kuang.demo1;

import java.util.ArrayList;
import java.util.List;

public class UnsafeList {
    public static void main(String[] args) {
        List<String>list=new ArrayList<String>();
        for(int i=0;i<1000;i++){
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(list.size());
        }
    }
}
同步方法
  • 由于我们可以通过private关键字来保证数据对象只能被方法访问﹐所以我们只需要针对方法提出一套机制,这套机制就是synchronized关键字，它包含两种用法∶synchronized方法和synchronized块.
  • 同步方法:public synchronized void method(int args){}
  • synchronized方法控制对“对象”的访问,每个对象对应一把锁,每个
    synchronized方法都必须获得调用该方法的对象的锁才能执行﹐否则线程会阻塞，方法一旦执行﹐就独占该锁，直到该方法返回才释放锁﹐后面被阻塞的线程才能获得这个锁,继续执行
  • 缺陷:若将一个大的方法申明为synchronized将会影响效率
  • 同步方法的弊端
    • 方法里面需要修改的内容才需要锁，锁的太多，浪费资源。
同步块
  • 同步块:synchronized((obj )}Obj称之为同步监视器
  • Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
  • 同步方法中无需指定同步监视器﹐因为同步方法的同步监视器就是this ,就是这个对象本身，或者是class[反射中讲解]
  • 同步监视器的执行过程
    • 第一个线程访问，锁定同步监视器﹐执行其中代码．
    • 第二个线程访问,发现同步监视器被锁定﹐无法访问.
    • 第一个线程访问完毕﹐解锁同步监视器．
    • 第二个线程访问,发现同步监视器没有锁﹐然后锁定并访问

案例买票：

package com.kuang.demo1;
//不安全的买票
//线程不安全，有负数
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station=new BuyTicket();
        new Thread(station,"苦逼的我").start();
        new Thread(station,"牛逼").start();
        new Thread(station).start();
        new Thread(station,"可恶的黄牛党").start();
    }
}
class BuyTicket implements Runnable{
//票
    private int ticketNums=10;
    boolean flag=true;
    @Override
    public void run() {
        while(flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //买票
    }
    private synchronized void buy() throws InterruptedException {
        //判断是否有票
        if(ticketNums<=0){
            flag=false;
            return;
        }
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);

    }
}

案例2：（取钱）

package com.kuang.demo1;

public class UnsafeBank {
    public static void main(String[] args) {
        Account account=new Account(100,"结婚资金");
        Drawing you=new Drawing(account,50,"王明");
        Drawing grilFriend=new Drawing(account,100,"王明对象");
        you.start();
        grilFriend.start();
    }
}
class Account{
    int money;//余额
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
//银行
class Drawing extends Thread{
    Account account;//账户
    int drawingMoney;//取了多少钱
    int nowMoney;//现在手里多少钱

    public Drawing( Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;

    }
    //取钱
    @Override
    public void run(){
        //判断有没有钱
        synchronized (account){
        if(account.money-drawingMoney<=0){
            System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
        return;
        }
       //sleep可以放大问题的放生性
       try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
       }
        //卡内余额=余额-你取的钱
        nowMoney=account.money-drawingMoney;
        System.out.println(account.name+"余额为"+account.money);
        System.out.println(this.getName()+"手里的钱"+nowMoney);
    }
    }
}

死锁

  • 多个线程各自占有一些共享资源﹐并且互相等待其他线程占有的资源才能运行﹐而导致两个或者多个线程都在等待对方释放资源﹐都停止执行的情形.某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题.

案例

package com.kuang.demo1;

public class Deadlock {
    public static void main(String[] args) {
        Makeup g1=new Makeup(0,"灰姑娘");
        Makeup g2=new Makeup(1,"白雪公主");

        g1.start();
        g2.start();
    }
}
    //口红
     class Lipstick{

    }
    //镜子
     class Mirrot{

    }
    class Makeup extends Thread{
        //只有一份资源，一份用static修饰
        static  Lipstick lipstick=new Lipstick();
        static  Mirrot mirrot=new Mirrot();



    int choice;
    String girlname;
    Makeup(int choice, String girlname){
        this.choice=choice;
        this.girlname=girlname;
    }
        @Override
        public void run(){
            //化妆
            try {
                makeup();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //化妆，相互持有对方的锁，就是需要闹到对方的资源
        private void makeup() throws InterruptedException {
        if (choice==0){
            synchronized (lipstick){
                System.out.println(this.girlname+"获得口红的锁");
                Thread.sleep(1000);
				//synchronized (mirrot){
               // System.out.println(this.girlname+"获得镜子的锁");
                }
            synchronized (mirrot){
                System.out.println(this.girlname+"获得镜子的锁");
            }
        }else{
            synchronized (mirrot){
                System.out.println(this.girlname+"获得镜子的锁");
              Thread.sleep(1000);
              synchronized (lipstick){
                  System.out.println(this.girlname+"获得口红的锁");
              }
        }
        }
     }


}
死锁的避免方法（sleep不能释放锁）
  • 产生死锁的四个必要条件:
  • 互斥条件:一个资源每次只能被一个进程使用。
  • 请求与保持条件:一个进程因请求资源而阻塞时，对已获得的资源保持不放
  • 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
  • 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
  • 总结：上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生
Lock(锁)

  • 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当

  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象

  • ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

  • 案例：

  • package com.kuang.demo1;

import java.util.concurrent.locks.ReentrantLock;

public class Testlock {
    public static void main(String[] args) {
        Testlock2 testlock2=new Testlock2();
        new Thread(testlock2).start();
        new Thread(testlock2).start();
        new Thread(testlock2).start();
    }
}
class Testlock2 implements Runnable{
    int ticketNums=10;
    //定义一个lock锁
    private final ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
       while (true) {
           try {

               lock.lock();//加锁
               if (ticketNums > 0) {
                   try {
                       Thread.sleep(1000);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println(ticketNums--);
               } else {
                   break;
               }
           }finally{
               //解锁
               lock.unlock();
       }
       }
    }
}
synchronized 与Lock 的对比一
  • Lock是显式锁（手动开启和关闭锁，别忘记关闭锁) synchronized是隐式锁，出了作用域自动释放
  • Lock只有代码块锁，synchronized有代码块锁和方法锁
    使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
  • 优先使用顺序:
    • Lock >同步代码块（已经进入了方法体，分配了相应资源)>同步方法（在方法体之外)

线程协作

生产者消费者模式
线程通信
  • 应用场景:生产者和消费者问题
    • 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费．
    • 如果仓库中没有产品，则生产者将产品放入仓库﹐否则停止生产并等待，直到仓库中的产品被消费者取走为止．
    • 如果仓库中放有产品﹐则消费者可以将产品取走消费﹐否则停止消费并等待，直到仓库中再次放入产品为止.

在这里插入图片描述

  • Java提供了几个方法解决线程之间的通信问题

  • wait()：表示线程一直等待，直到其他线程通知，与sleep不同﹐会释放锁

  • wait(long timeout)：指定等待的毫秒数

  • notify()：唤醒一个处于等待状态的线程

  • notifyAll()：唤醒同一个对象上所有调用wait()方法的线程﹐优先级别高的线程优先调度

  • 注意:均是Object类的方法,都只能在同步方法或者同步代码块中使用,否则会抛出异常lllegalMonitorStateException

  • 解决方式1

    • 并发协作模型“生产者/消费者模式”—>管程法

      • 生产者:负责生产数据的模块(可能是方法﹐对象﹐线程﹐进程);
      • 消费者:负责处理数据的模块(可能是方法﹐对象,线程,进程);
      • 缓冲区︰消费者不能直接使用生产者的数据﹐他们之间有个“缓冲

    • 生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据

    • 案例：

    • package com.kuang.demo1;

import java.util.concurrent.Callable;

//测试：生产者消费者模式-->利用缓冲区：管程法
//生产者，消费者，产品，缓冲区
public class TestPc {
    public static void main(String[] args) {
        SynContainer container=new SynContainer();
        new Productor(container).start();
        new Consummer(container).start();
    }
}
//生产者
class Productor extends Thread{
    SynContainer container;
    public Productor(SynContainer container){
        this.container=container;
    }
    @Override
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println("生产了"+i+"只鸡");
            container.push(new Chicken(i));
        }
    }
}
//消费者
class Consummer extends Thread{
    SynContainer container;
    public Consummer(SynContainer container){
        this.container=container;
    }
    //消费
    @Override
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println("消费了-->"+container.pop().id+"只鸡");

        }
    }
}
//产品
class Chicken{
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}
//缓冲区
class SynContainer {
    //需要一个容器大小
    Chicken [] chickens=new Chicken[10];
    int count =0;
    //生产者放入产品
    public synchronized  void push(Chicken chicken){
        if(count==chickens.length){
            //如果容器满了，就通知消费者 消费
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满，我们就需要丢入产品
        chickens[count]=chicken;
        count++;
        //可以通知消费者消费
        this.notifyAll();
        }
        //消费者消费产品
    public synchronized Chicken pop(){
        //判断消费者是否能消费
        if(count==0){
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken=chickens[count];
        //吃完了，通知生产者生产
        this.notifyAll();
        return chicken;
    }

}

  • 解决方法2

    • 并发协作模式“生产者/消费者模式”–>信号灯法

    • 案例：

    • package com.kuang.demo1;
//测试标志位解决
public class Testpc2 {
    public static void main(String[] args) {
        TV tv=new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}
//生产者--演员
class Player extends Thread {
    TV tv;
    public Player(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                this.tv.play("快乐大本营播放中");
            }else{
                this.tv.play("抖音记录美好生活");
            }
        }
    }
}

    // 消费者--观众
    class Watcher extends Thread {
        TV tv;
        public Watcher( TV tv){
            this.tv=tv;
        }
        @Override
        public void run(){
            for(int i=0;i<20;i++){
                tv.watch();
            }

        }

    }

    //产品---节目
    class TV {
        //演员表演，观众等待
        //观众观看，演员等待f
        String voice;//表演节目
        Boolean flag = true;

        //表演
        public synchronized void play(String voice) {
            if (!flag) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("演员表演了" + voice);
            //通知观众观看
            this.notifyAll();//通知唤醒
            this.voice = voice;
            this.flag = !this.flag;
        }


        //观看
        public synchronized void watch() {
            if (flag) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("观看了" + voice);
            //通知演员表演
            this.notifyAll();
            this.flag = !this.flag;
        }
    }
使用线程池

  • 背景:经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

  • 思路:提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

  • 好处:

    • 提高响应速度（减少了创建新线程的时间)
    • 降低资源消耗（重复利用线程池中线程，不需要每次都创建)
    • 便于线程管理(…)
      • corePoolSize:核心池的大小
      • maximumPoolSize:最大线程数
      • keepAliveTime:线程没有任务时最多保持多长时间后会终止

  • JDK 5.0起提供了线程池相关API:ExecutorService和Executors

  • ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor

    • void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable
    • Future submit(Callable task):执行任务，有返回值，一般又来执行Callable
    • void shutdown()∶关闭连接池
    • Executors:工具类、线程池的工厂类，用于创建并返回不同类型的线程池

案例：

package com.kuang.demo1;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestPool {
    public static void main(String[] args) {
        //newFixedThreadPool:参数为：线程池大小
        ExecutorService service =  Executors.newFixedThreadPool(10);
       //执行
        service.execute((new MyThread()));
        service.execute((new MyThread()));
        service.execute((new MyThread()));
        //关闭连接
        service.shutdown();
    }
}
class MyThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());

    }
}

总结：

案例：

package com.kuang.demo1;


import java.sql.SQLOutput;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//回顾总结线程的创建
public class ThreadNew {
    public static void main(String[] args) {
        new MyThread1().start();
        new Thread(new MyThread2()).start();
        FutureTask<Integer> futureTask=new FutureTask<Integer>(new Mythread3());
        new Thread(futureTask).start();
        try {
          Integer integer= futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}
//1.继承Thread类
class MyThread1 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread1");
    }
}
    //2.实现Runnable接口
    class MyThread2 implements  Runnable{
        @Override
        public void run() {
            System.out.println("MyThread2");
        }
    }
    //3.实现Callable接口
class Mythread3 implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            System.out.println("MyThread3");
            return 100;
        }
        }

MyThread()));
service.execute((new MyThread()));
service.execute((new MyThread()));
//关闭连接
service.shutdown();
}
}
class MyThread implements Runnable{

@Override
public void run() {
    System.out.println(Thread.currentThread().getName());

}

}


总结：

案例：

```java
package com.kuang.demo1;


import java.sql.SQLOutput;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//回顾总结线程的创建
public class ThreadNew {
    public static void main(String[] args) {
        new MyThread1().start();
        new Thread(new MyThread2()).start();
        FutureTask<Integer> futureTask=new FutureTask<Integer>(new Mythread3());
        new Thread(futureTask).start();
        try {
          Integer integer= futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}
//1.继承Thread类
class MyThread1 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread1");
    }
}
    //2.实现Runnable接口
    class MyThread2 implements  Runnable{
        @Override
        public void run() {
            System.out.println("MyThread2");
        }
    }
    //3.实现Callable接口
class Mythread3 implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            System.out.println("MyThread3");
            return 100;
        }
        }
菜鸟想飞了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线程学习总结
qq_47499256的博客
11-21 335
1.线程和进程 1.1进程的概念 进程就是正在运行的程序,它会占用对应的内存区域，由CPU进行执行与计算。 1.2线程的概念 线程是操作系统OS能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位. 1.3多线程并发和并行 并发：两个或多个事件在同一时间间隔发生。 并行：两个或者多个事件在同一时刻发生。 并行是真正意义上，同一时刻做多件事情，而并发在同一时刻只会做一件事件，只是可以将时间切碎，交替做多件事情。 网上有个例子挺形...
线程的学习
z184162946的博客
05-28 264
CPU难道真的很神通广大，能够同时执行那么多程序吗？不是的，CPU的执行是这样的：CPU的速度很快，一秒钟可以算好几亿次，因此CPU把自己的时间分成一个个小时间片，我这个时间片执行你一会，下一个时间片执行他一会，再下一个时间片又执行其他人一会，虽然有几十个线程，但一样可以在很短的时间内把他们通通都执行一遍，但对我们人来说，CPU的执行速度太快了，因此看起来就像是在同时执行一样，但实际上在一个时间点上，CPU只有一个线程在运行。 学习线程首先要理清楚三个概念： 进程：进程是一个静态的概念 线程：一个进
线程的学习——基本知识
weixin_61050264的博客
02-08 265
/** * 基础知识： * 线程：线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序控制的流程，但与进程不同的 * 是，同类的多个线程是共享一块内存空间和一组系统资源。所以系统在各个线程之间切换时，开销要 * 比进程小的多，正因如此，线程被称为轻量级进程。一个进程中可以包含多个线程。 * 主线程： * Java程序至少会有一个线程，这就是主线程，程序启动后是由JVM创建主线程，程序结束时由JVM停 * 止主线程。主线程它负责管理子线.
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
学习目录：1. 线程简介 2. 线程实现（重点） 3. 线程状态 4. 线程同步（重点） 5. 线程通信问题 6. 高级主题
狂神说多线程详解.rar
05-06
狂神说多线程详解笔记
狂神说各种学习视频配套笔记
05-30
包括Java、html、CSS、JavaScript、Mysql、JavaWeb、Mybatis、SpringMVC、Linux、Redis、SpringCloud等
多线程-狂神说Java学习笔记
07-19
狂神说Java学习笔记（笔记+源代码+图片)—多线程
狂神说Java-多线程课程全部代码.rar
11-26
狂神说Java-多线程课程全部代码.rar
大数据入门教程
weixin_44223683的博客
01-08 2231
第1章Linux概述 1.1 Linux简介 1.1.1 Linux是什么 Linux是一套免费使用操作系统，是一个基于多用户、多任务、支持多线程和多CPU的操作系统。它支持32位和64位硬件，是一个性能稳定的多用户网络操作系统。Linux操作系统诞生于1991 年10 月5 日（这是第一次正式向外公布时间），是由芬兰人Linus Benedict Torvalds（李纳斯.托沃兹，如图1-1所示...
进程和线程学习理解
shenwanjiang111的专栏
04-28 2880
1 fork基本概念 一个进程，包括代码、数据和分配给进程的资源。fork()函数通过系统调用创建一个与原来进程几乎完全相同的进程，也就是两个进程可以做完全相同的事，但如果初始参数或者传入的变量不同，两个进程也可以做不同的事。     一个进程调用fork()函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。然后把原来的进程的所有值都复制到新的新进程中，只有少数值与原来的进程的值不同
Java三种方式创建线程
MrWu的博客
11-13 541
Java创建线程的三种方式 继承Java的Thread类 继承Thread类，在子类中重写run()方法，实现线程处理的内容，然后创建子类实例，调用start()方法启动线程 Thread类常用方法： Thread currentThread()：获取当前线程实例； String getName()：获取线程名称； setName()：设置线程名称； sleep()：休眠线程 import java.io.*; import java.util.*; import java.lang.*; publi
同步练习(Java SE(十一))
weixin_52993606的博客
11-23 608
案例一: UDP通信练习 需求: 按照下面的要求实现程序 UDP发送数据: 数据来自于键盘录入，知道输入的数据是886，发送数据结束 UDP接受数据: 因为接受端不知道发送端什么时候停止发送，故采用死循环接受 发送端 package test.test88; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import jav...
Java多线程学习（吐血超详细总结）
&&
04-06 4600
转自：http://www.mamicode.com/info-detail-517008.html 目录(?)[-] 一扩展javalangThread类二实现javalangRunnable接口三Thread和Runnable的区别四线程状态转换五线程调度六常用函数说明 使用方式为什么要用join方法 七常见线程名词解释八线程同步九线程数据传递      本文
java多线程学习（一）
hust_superman的专栏
09-19 1567
一、操作系统中线程和进程的概念 线程是指进程内的一个执行单元，也是进程内的可调度实体。 线程与进程的区别： (1)地址空间：线程为进程内的一个执行单元；进程至少有一个线程(进程的主线程)；进程的所有线程共享进程的地址空间；而进程有自己的独立的地址空间。 (2)资源拥有：进程是资源分配和拥有的单位，同一个进程内的线程共享进程的资源。 (3)线程是处理器调度的基本单元，但进程不是。 (4)
centos 6 odbc mysql_Linux学习之CentOS(一)--CentOS6.6下Mysql数据库的安装与配置
weixin_42498987的博客
01-26 258
在这里我是通过yum来进行mysql数据库的安装的，通过这种方式进行安装，可以将跟mysql相关的一些服务、jar包都给我们安装好，所以省去了很多不必要的麻烦！！！[root@larry ~]# cat /etc/redhat-release //查看操作系统版本CentOS release 6.6 (Final)1.卸载掉原有mysql因为mysql数据库在Linux上实在是太流行了，所以目前...
异步和多线程学习（一）
满天星的博客
07-03 9407
零、学习目录：1 进程-线程-多线程，同步和异步2 委托启动异步调用3 多线程特点：不卡主线程、速度快、无序性4 异步的回调和状态参数5 异步等待三种方式6 异步返回值一、进程-线程-多线程，同步和异步1.什么是进程？当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。而一个进程又是由多个线程所组成的。2.什么是线程？线程是程序中的一个执行流，每个线程都有自己...
腾讯云（Ubuntu）+WordPress 搭建个人博客
weixin_42009192的博客
09-06 1779
本文仅供学习交流，如有错误纰漏，还请谅解，欢迎大家一起来学习探讨！参考资料（感谢！）购买腾讯云服务器（Ubuntu）登入云服务器搭建LAMP环境下载并配置WordPress安装WordPress（后续继续撰写中。。） 参考资料（感谢！） 基于 Ubuntu 搭建 WordPress 个人博客： https://cloud.tencent.com/developer/labs/lab/10122 购...
狂神说java多线程笔记
最新发布
10-11
狂神在他的Java多线程笔记中，详细介绍了Java多线程的相关知识，包括线程的创建、启动、停止、等待、唤醒等操作，以及线程安全、锁、同步等概念和技术。 在Java多线程中，线程的创建有两种方式：继承Thread类和实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值