线程: 创建 & 自定义 & 安全 & 常用方法 & 通讯 & 停止 & 守护 & 加入

线程基础

  • 进程 : 进程就是正在运行的应用程序; 进程负责了内存空间的划分
  • 问题 : windows号称是多任务的操作系统, 那么windows是同时运行多个应用程序吗?
    从宏观的角度 : windows确实是在同时运行多个应用程序
    从微观角度 : cpu是做了一个快速切换执行的动作，由于速度态度，所以我感觉不到在切换而已
  • 线程 : 一个进程中的代码是由线程负责执行的，就是进程中一个执行路径
  • 多线程 : 在一个进程中有多个线程同时在执行不同的任务
  • 关于线程的一些问题 :
    • 线程负责了代码的执行，为什么没有创建线程, 代码就可以执行呢?
      运行任何一个java程序，jvm在运行的时候都会创建一个main线程执行main方法中所有代码
    • 一个java应用程序至少有几个线程？
      一个java程序至少有两个线程, 一个是主线程负责main方法代码的执行, 一个是垃圾回收器线程, 负责了回收垃圾
  • 多线程的好处：
    1. 解决了一个进程能同时执行多个任务的问题
    2. 提高了资源的利用率
  • 多线程的弊端：
    1. 增加cpu的负担
    2. 降低了一个进程中线程的执行概率
    3. 引发了线程安全问题
    4. 出现了死锁现象
    • 什么是死锁现象?
      死锁现象出现的根本原因:
      1. 存在2个或者2个以上的线程
      2. 存在2个或者2个以上的共享资源
    • 死锁现象的解决方案: 只能尽量避免出现死锁问题
  • 如何创建多线程：
    1. 自定义一个类继承Thread类
    2. 重写Thread类的run方法 , 把自定义线程的任务代码写在run方法中
    • 重写run方法的目的是什么？
      每个线程都有自己的任务代码, jvm创建的主线程的任务代码就是main方法中的所有代码, 自定义线程的任务代码就写在run方法中, 自定义线程负责了run方法中代码
    1. 创建Thread的子类对象，并且调用start方法开启线程
      注意 : 一个线程一旦开启，那么线程就会执行run方法中的代码，run方法千万不能直接调用, 直接调用run方法就相当调用了一个普通的方法而已并没有开启新的线程
public class Demo1 extends Thread {
   
   @Override  //把自定义线程的任务代码写在run方法中。
   public void run() {
       for(int i  = 0 ; i < 100 ; i++){
           System.out.println("自定义线程："+i);
       }
   }
   
   public static void main(String[] args) {
       //创建了自定义的线程对象。
       Demo1 d = new Demo1();
       //调用start方法启动线程
       d.start();
       
       for(int i  = 0 ; i < 100 ; i++){
           System.out.println("main线程："+i);
       }
   }
}

线程常用的方法：

  1. Thread(String name) 初始化线程的名字
  2. setName(String name) 设置线程对象名
  3. getName() 返回线程的名字
  4. sleep() 线程睡眠指定的毫秒数 (静态的方法, 那个线程执行了sleep方法代码那么就是那个线程睡眠)
  5. currentThread() 返回当前的线程对象, 该方法是一个静态的方法; 注意 : 那个线程执行了currentThread()代码就返回那个线程的对象
  6. getPriority() 返回当前线程对象的优先级 默认线程的优先级是5
  7. setPriority(int newPriority) 设置线程的优先级 虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的实现（最大的优先级是10 ，最小的1 ， 默认是5)
public class Demo3 extends Thread {
    
    public Demo3(String name){
        super(name); //调用了Thread类的一个 参数的构造方法。
    }
    
    @Override
    public void run() {
        /*System.out.println("this:"+ this);
        System.out.println("当前线程对象：" + Thread.currentThread()); */
        
        for (int i = 0; i < 100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            /*try {
                Thread.sleep(100);  //为什么在这里不能抛出异常，只能捕获？？ Thread类的run方法没有抛出异常类型，所以子类不能抛出异常类型。
            } catch (InterruptedException e) {
                e.printStackTrace();
            } */
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        //创建了一个线程对象
        Demo3 d = new Demo3("狗娃");
        d.setPriority(10); //设置线程 的优先级。 优先级的数字越大，优先级越高  ， 优先级的范围是1~10
        d.start();
        
        for (int i = 0; i < 100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
        
        /*
        System.out.println("自定义线程的优先级："+d.getPriority());  //线程的优先级默认是5
        System.out.println("主线程的优级："+Thread.currentThread().getPriority());
        
        d.start();
        d.setName("铁蛋"); //setName设置线程的名字
        d.start(); //开启线程 
        
        Thread mainThread = Thread.currentThread();
        System.out.println("主线程的名字："+ mainThread.getName());
    */
    }
}

线程安全

  • 线程安全出现的根本原因：
    1. 存在两个或者两个以上的线程对象共享同一个资源
    2. 多线程操作共享资源的代码有多句
  • 线程安全问题的解决方案：
    1. 方式一 : 可以使用同步代码块去解决
      格式：
                synchronized(锁对象){
            需要被同步的代码
        }

  - 同步代码块要注意的事项：
    1. 锁对象可以是任意的一个对象
    2. 一个线程在同步代码块中sleep了，并不会释放锁对象
    3. 如果不存在着线程安全问题，千万不要使用同步代码块，因为会降低效率
    4. 锁对象必须是多线程共享的一个资源，否则锁不住
  1. 方式二：同步函数, 就是使用synchronized修饰一个函数
- 同步函数要注意的事项 ：
    1. 如果是一个非静态的同步函数的锁 对象是this对象，如果是静态的同步函数的锁对象是当前函数所属的类的字节码文件（class对象）(类的字节码文件是什么? -> class类用于描述字节码文件, 当创建一个字节码文件对象的时候, 会把字节码文件加载到内存(方法去)中, 然后对字节码文件的所有成员进行解剖, 然后把解剖出来的所有信息保存到一个class类的对象中去, 把类文件的信息全部都保存到该对象中)
    2. 同步函数的锁对象是固定的, 不能由你来指定的
  1. 推荐使用: 同步代码块
    1. 同步代码块的锁对象可以由我们随意指定方便控制; 同步函数的锁对象是固定的, 不能由我们来指定
    2. 同步代码块可以很方便控制需要被同步代码的范围，同步函数必须是整个函数的所有代码都被同步了
需求： 一个银行账户5000块，两夫妻一个拿着 存折，一个拿着卡，开始取钱比赛，每次只能取一千块，要求不准出现线程安全问题。
        
class BankThread extends Thread{
    
    static  int  count = 5000;
    public BankThread(String name){
        super(name);
    }
    
    @Override  //
    public synchronized  void run() {
        while(true){
            synchronized ("锁") {                
                if(count>0){
                    System.out.println(Thread.currentThread().getName()+"取走了1000块,还剩余"+(count-1000)+"元");
                    count= count - 1000;
                }else{
                    System.out.println("取光了...");
                    break;
                }
            }
        }
    }   
        
//静态的函数---->函数所属的类的字节码文件对象--->BankThread.class是唯一的
    public static synchronized  void getMoney(){
        
    }   
}

public class Demo{
    public static void main(String[] args) {
        //创建两个线程对象
        BankThread thread1 = new BankThread("老公");
        BankThread thread2 = new BankThread("老婆");
        //调用start方法开启线程取钱
        thread1.start();
        thread2.start();    
    }
}

自定义线程的创建方法

  • 自定义线程的创建方式:

    • 方式一 ：
      1. 自定义一个类继承Thread类
      2. 重写Thread类的run方法，把自定义线程的任务代码写在run方法上
      3. 创建Thread的子类对象，并且调用start方法启动一个线程
      注意：千万不要直接调用run方法，调用start方法的时候线程就会开启，线程一旦开启就会执行run方法中代码，如果直接调用run方法，那么就 相当于调用了一个普通的方法而已

    • 方式二：
      1. 自定义一个类实现Runnable接口
      2. 实现Runnable接口的run方法，把自定义线程的任务定义在run方法上
      3. 创建Runnable实现类对象
      4. 创建Thread类 的对象，并且把Runnable实现类的对象作为实参传递
      5. 调用Thread对象 的start方法开启一个线程

  • 问题1： 请问Runnable实现类的对象是线程对象吗？
    Runnable实现类的对象并 不是一个线程对象，只不过是实现了Runnable接口 的对象而已。
    只有是Thread或者是Thread的子类才是线程对象。

  • 问题2 : 为什么要把Runnable实现类的对象作为实参传递给Thread对象呢？作用是什么？
    作用就是把Runnable实现类的对象的run方法作为了线程的任务代码去执行了。
    推荐使用： 第二种。 实现Runable接口的( 因为java单继承, 多实现 )

public class Demo implements Runnable{

    @Override
    public void run() {
        /*System.out.println("this："+ this);
        System.out.println("当前线程："+ Thread.currentThread());*/
        for(int i = 0 ; i < 100 ; i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
    
    public static void main(String[] args) {
        //创建Runnable实现类的对象
        Demo d = new Demo();
        //创建Thread类的对象， 把Runnable实现类对象作为实参传递。
        Thread thread = new Thread(d, "狗娃");  //Thread类使用Target变量记录了d对象，
        //调用thread对象的start方法开启线程。
        thread.start();
                
        for(int i = 0 ; i < 100 ; i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    } 
    
    /*
      Thread类的run方法
      
     *  @Override
        public void run() {
            if (target != null) {
                target.run();  //就相当于Runnable实现类的对象的run方法作为了Thread对象的任务代码了。
            }
        }
    */
}

线程通讯

  • 线程通讯 : 一个线程完成了自己的任务时，要通知另外一个线程去完成另外一个任务

  • 生产者与消费者:

    • wait() : 等待, 如果线程执行了wait方法, 那么该线程会进入等待的状态, 等待状态下的线程必须要被其他线程调用notify方法才能唤醒 (方法详解: 一个线程如果执行了wait方法, 那么jvm就会建立一个以锁对象为标识符的线程池(线程池仅仅是存放线程的一个"数组")将其放进线程池中等待; 一旦执行wait方法会释放锁对象)
    • notify() : 唤醒, 唤醒线程池等待线程其中的一个 (方法详解: 如果一个线程执行notify方法, 那么就会唤醒以锁对象为标识符建立的线程池中等待的线程中的, 其中一个线程(一般先等待的先被唤醒))
    • notifyAll() : 唤醒线程池中所有等待的线程

  • wait与notify方法要注意的事项：

    1. wait方法与notify方法是属于Object对象的(为什么不设计到thread上面? 因为锁对象可以是任意对象, 如果设计在thread上面, 那么锁对象就不能是任意对象)
    2. wait方法与notify方法必须要在同步代码块或者是同步函数中才能使用(如果不是在同步代码块或者是同步函数中, 就没有锁对象存在)
    3. wait方法与notify方法必需要由锁对象调用(因为要以锁对象标识符建立一个线程池)

问题一：出现了线程安全问题: 价格错乱了...

//产品类
class Product{
   String name;  //名字  
   double price;  //价格
   boolean flag = false; //产品是否生产完毕的标识，默认情况是没有生产完成。
}

//生产者
class Producer extends Thread{
   Product  p ;    //产品
   public Producer(Product p) {
       this.p  = p ;
   }
   
   @Override
   public void run() {
       int i = 0 ; 
       while(true){
        synchronized (p) {
           if(p.flag==false){
                if(i%2==0){
                    p.name = "苹果";
                    p.price = 6.5;
                }else{
                    p.name="香蕉";
                    p.price = 2.0;
                }
                System.out.println("生产者生产出了："+ p.name+" 价格是："+ p.price);
                p.flag = true;
                i++;
                p.notifyAll(); //唤醒消费者去消费
           }else{
               //已经生产 完毕，等待消费者先去消费
               try {
                   p.wait();   //生产者等待
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }   
       }   
   }
}

//消费者
class Customer extends Thread{
   Product p; 
   public  Customer(Product p) {
       this.p = p;
   }
   
   @Override
   public void run() {
       while(true){
           synchronized (p) {  
               if(p.flag==true){  //产品已经生产完毕
                   System.out.println("消费者消费了"+p.name+" 价格："+ p.price);
                   p.flag = false; 
                   p.notifyAll(); // 唤醒生产者去生产
               }else{
                   //产品还没有生产,应该 等待生产者先生产。
                   try {
                       p.wait(); //消费者也等待了...
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           }
       }   
   }
}

public class Demo {
   public static void main(String[] args) {
       Product p = new Product();  //产品
       //创建生产对象
       Producer producer = new Producer(p);
       //创建消费者
       Customer customer = new Customer(p);
       //调用start方法开启线程
       producer.start();
       customer.start();
   }
}

线程的停止

  1. 停止一个线程我们一般都会通过一个变量去控制的
  2. 如果需要停止一个处于等待状态下的线程，那么我们需要通过变量配合notify方法或者interrupt()来使用
public class Demo extends Thread {
    
    boolean flag = true;
    public Demo6(String name){
        super(name);
    }
    
    @Override
    public synchronized void run() {
        int i = 0 ;
        while(flag){
            try {
                this.wait(); //狗娃等待..
            } catch (InterruptedException e) {
                System.out.println("接收到了异常了....");
            }
            System.out.println(Thread.currentThread().getName()+":"+i);
            i++;
        }
    }
    
    public static void main(String[] args) {
        Demo d = new Demo6("狗娃");
        d.setPriority(10);
        d.start();
        
        for(int i = 0 ; i<100 ; i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            //当主线程的i是80的时候停止狗娃线程。
            //d.interrupt();  // interrupt()根本就是无法停止一个线程。
            if(i==80){
                d.flag = false;
                d.interrupt(); //把线程的等待状态强制清除，被清除状态的线程会接收到一个InterruptedException。 
                /*synchronized (d) {                    
                    d.notify();
                }*/ 
            }   
        }   
    }
}

守护线程（后台线程）

  • 简介: 守护线程, 类似QQ的更新包, 不经过用户同意直接下载 -> 就是守护线程做的事情
  • 在一个进程中如果只剩下了守护线程，那么守护线程也会死亡; 一个线程默认都不是守护线程
  • 方法:
    1. 设置线程为守护线程: setDaemon(true) / setDaemon(false)
    2. 判断线程是否为守护线程: isDaemon()
public class Demo extends Thread {
    public Demo(String name){
        super(name);
    }
    
    @Override
    public void run() {
        for(int i = 1 ; i<=100 ; i++){
            System.out.println("更新包目前下载"+i+"%");
            if(i==100){
                System.out.println("更新包下载完毕,准备安装..");
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String[] args) {
         Demo d = new Demo("后台线程");
         d.setDaemon(true); //setDaemon() 设置线程是否为守护线程，true为守护线程， false为非守护线程。
        // System.out.println("是守护线程吗？"+ d.isDaemon()); //判断线程是否为守护线程。
         d.start();

         for(int i = 1 ; i<=100 ; i++){
             System.out.println(Thread.currentThread().getName()+":"+i);
         }   
    }
}

加入线程: join

  • 一个线程如果执行join语句，那么就有新的线程加入，执行该语句的线程必须要让步给新加入的线程先完成任务，然后才能继续执行
class  Mon extends Thread{
    
    public void run() {
        System.out.println("妈妈洗菜");
        System.out.println("妈妈切菜");
        System.out.println("妈妈准备炒菜，发现没有酱油了..");
        //叫儿子去打酱油
        Son s= new Son();
        s.start();
        try {
            s.join();  //加入: 一个线程如果执行join语句，那么就有新的线程加入，执行该语句的线程必须要让步给新加入的线程先完成任务，然后才能继续执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("妈妈继续炒菜");
        System.out.println("全家一起吃饭..");     
    }
} 

class Son extends Thread{
    
    @Override
    public void run() {
        System.out.println("儿子下楼..");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("儿子一直往前走");
        System.out.println("儿子打完酱油了");
        System.out.println("上楼，把酱油给老妈");
    }
}

public class Demo {
    public static void main(String[] args) {
        Mon m = new Mon();
        m.start();      
    }
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,189评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,577评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 150,857评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,703评论 1赞 276
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,705评论 5赞 366
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,620评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,995评论 3赞 396
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,656评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,898评论 1赞 298
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,639评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,720评论 1赞 330
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,395评论 4赞 319
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,982评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,953评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,195评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 44,907评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,472评论 2赞 342

推荐阅读更多精彩内容

  • java多线程
    本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。 首先讲...
    李欣阳阅读 2,438评论 1赞 15
  • Java多线程学习
    Java多线程学习 [-] 一扩展javalangThread类 二实现javalangRunnable接口 三T...
    影驰阅读 2,949评论 1赞 18
  • Java多线程学习（吐血超详细总结）
    该文章转自：http://blog.csdn.net/evankaka/article/details/44153...
    加来依蓝阅读 7,331评论 3赞 87
  • Java多线程基础学习
    写在前面的话： 这篇博客是我从这里“转载”的，为什么转载两个字加“”呢？因为这绝不是简单的复制粘贴，我花了五六个小...
    SmartSean阅读 4,709评论 12赞 45
  • 何处是故乡
    对于每次人问，你是哪里人？ 这个问题，自己总会带着戏虐的回答方式，先反问，你是哪里啊？ 对哦，我是哪里人呢？ 作为...
    芙筱筱Elaine阅读 230评论 0赞 0