Java基础——线程

线程

示意图

相关概念

程序(program)

是为完成特定任务、用某种语言编写的一组指令的集合。简单的说:就是我们写的代码

进程

1. 进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程,操作系统将为迅雷分配新的内存空间。
2. 进程是程序的一次执行过程,或是正在运行的一个程序。是动态过程:有它自身的

线程

1. 线程由进程创建的,是进程的一个实体
2. 一个进程可以拥有多个线程

单线程

同一个时刻，只允许执行一个线程

多线程

同一个时刻,可以执行多个线程，比如:一个qq进程，可以同时打开多个聊天窗口,一个迅雷进程,可以同时下载多个文件

并发

同一个时刻,多个任务交替执行，造成一种“貌似同时”的错觉,简单的说，单核cpu实现的多任务就是并发。

并行

同一个时刻,多个任务同时执行。多核cpu可以实现并行。

用户线程

也叫工作线程,当线程的任务执行完或通知方式结束

守护线程

一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束常见的守护线程:垃圾回收机制

用法

myDaemonThread.setDaemon(true);

基本语法

创建线程

• 继承Thread类,重写run方法

  • 应用案例

    package Thread;
    
    public class txt01 {
        public static void main(String[] args) {
            //1。当一个类继承了 Thread 类，该类就可以当做线程使用
            ///2．我们会重写 run方法，写上自己的业务代码
            //3. run Thread 类实现了 Runnable 接口的run方法
            /*
            Override
            public void run() {
                if (target != null) {
                    target.run();
                }
            }
            */
    //      请编写程序,开启一个线程,该线程每隔1秒。
    //              在控制台输出“我是小猫咪”
    //        对上题改进:当输出80次瞄噬，我是小猫咪,结束该线程
            //创建Cat对象，可以当做线程使用
            Cat cat = new Cat();
            cat.start();//启动线程->最终会执行cat的run方法
    //      cat.run() ;//run方法就是一个普通的方法，没有真正的启动一个线程,|
    //      说明:当main线程启动一个子线程Thread-0，
    //      主线程不会阻塞，会继续执行门这时主线程和子线程是交替执行..
    //        (1)
    //        public synchronized void start() {
    //            start0();
    //        }
    //        (2)start0()是本地方法,是JVM调用,底层是c/c++实现
    //          真正实现多线程的效果，是start0()，而不是 run
            System.out.println("主线程继续执行" +Thread.currentThread(). getName());//名字main
            for(int i = 0; i < 60;i++) {
                System.out.println("主线程i="+i);//让主线程休眠
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
        }
    }
    class Cat extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 9; i++) {
                System.out.println("我是小猫咪"+Thread.currentThread().getName());
            }
        }
    }
    

• 实现Runnable接口,重写run方法

  • 应用案例

    package Thread;
    
    public class txt02 {
        public static void main(String[] args) {
    //       java是单继承的,在某些情况下一个类可能已经继承了某个父类,
    //       这时在用继承Thread类方法来创建线程显然不可能了。
    //       java设计者们提供了另外一个方式创建线程,
    //       就是通过实现Runnable接口来创建线程
    //        请编写程序该程序可以每隔1秒。在控制台输出“hi!”,
    //        当输出10次后，自动退出。请使用实现Runnable接口的方式实现。
        person p1=new person();
        Thread t=new Thread(p1);
        t.start();
        }
    }
    class person implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 8; i++) {
                System.out.println("hi");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    

继承Thread vs 实现Runnable的区别

• 从java的设计来看,通过继承Thread或者实现Runnable接口来创建线程本质上没有区别,从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口
• 实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制

线程终止

1. 当线程完成任务后，会自动退出。
2. 还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

应用案例

package Thread;

public class txt03 {
    public static void main(String[] args) {
//        需求:启动一个线程t，要求在main线程中去停止线程t,请编程实现.
        M m = new M();
        m.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        m.setLoop(false);
    }
}
class M extends Thread{
    //设置一个控制变量，用来终止程序的运行
    boolean loop=true;
    public void setLoop(boolean loop) { this.loop = loop; }
    @Override
    public void run() {
        while (loop) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("i");
        }
    }
}

常用方法

• setName //设置线程名称,使之与参数name 相同
• getName //返回该线程的名称
• start //使该线程开始执行;Java虚拟机底层调用该线程的start0方法
• run //调用线程对象 run方法;
• setPriority //更改线程的优先级
• getPriority //获取线程的优先级
• sleep //在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
• interrupt //中断线程

注意事项

1. start 底层会创建新的线程，调用run, run 就是一个简单的方法调用，不会启动新线程

2. 线程优先级的范围

3. interrupt,中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程. sleep:线程的静态方法,使当前线程休眠

4. yield:线程的礼让。让出cpu,让其他线程执行,但礼让的时间不确定,所以也不一定礼让成功

5. join: 线程的插队。插队的线程一旦插队成功,则肯定先执行完插入的线程所有的任务

   插队练习

   package Thread;
   
   public class txt04 {
       public static void main(String[] args) {
   //       主线程每隔1s，输出hi,一共10次当输出到hi 5时，
   //       启动一个子线程(要求实现Runnable)，每隔1s输出hello，
   //       等该线程输出10次hello后,退出
   //       主线程继续输出hi，直到主线程退出.
           N n = new N();
           for (int i = 0; i < 10; i++) {
               try {
                   Thread.sleep(10);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("hi");
               if (i==5){
                   Thread t=new Thread(n);
                   t.start();
                   try {
                       t.join();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           }
           System.out.println("主线程结束......");
       }
   }
   class N implements Runnable{
       @Override
       public void run() {
           for (int i = 0; i < 10; i++) {
               try {
                   Thread.sleep(10);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("hello");
           }
           System.out.println("子线程结束...");
       }
   }
   

线程同步机制

1. 在多线程编程，一些敏感数据不允许被多个线程同时访问,此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性。
2. 也可以这里理解:线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作,直到该线程完成操作,其他线程才能对该内存地址进行操作.

使用方法

1. 同步代码块

   synchronized(对象){//得到对象的锁，才能操作同步代码

   ​ //需要被同步代码;

   }

2. synchronized还可以放在方法声明中，表示整个方法-为同步方法

   public synchronized void m (String name){

   ​ //需要被同步的代码

​ }

线程的状态

分类

• NEW 尚未启动的线程处于此状态。
• RUNNABLE 在Java虚拟机中执行的线程处于此状态。
• BLOCKED 被阻塞等待监视器锁定的线程处于此状态。
• WA工TING 正在等待另一个线程执行特定动作的线程处于此状态。
• TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
• TERMINATED 已退出的线程处于此状态。

互斥锁

基本介绍

1. Java语言中，引入了对象互斥锁的概念,来保证共享数据操作的完整性。
2. 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻,只能有一个线程访问该对象。
3. 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时,表明该对象在任一时刻只能由一个线程访问
4. 同步的局限性:导致程序的执行效率要降低
5. 同步方法（非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)
6. 同步方法（静态的）的锁为当前类本身。

注意细节

1. 同步方法如果没有使用static修饰:默认锁对象为this

2. 如果方法使用static修饰,默认锁对象:当前类.class

3. 实现的落地步骤:
   需要先分析上锁的代码

   选择同步代码块或同步方法

   要求多个线程的锁对象为同一个即可

线程的死锁

多个线程都占用了对方的锁资源，但不肯相让，导致了死锁,在编程是一定要避免死锁的发生.

释放锁

释放锁的操作

1. 当前线程的同步方法、同步代码块执行结束

   案例:上厕所,完事出来

2. 当前线程在同步代码块、同步方法中遇到break、return。

   案例:没有正常的完事,经理叫他修改bug,不得已出来

3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束

   案例:没有正常的完事,发现忘带纸,不得已出来

4. 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

不会释放锁的操作

1. 线程执行同步代码块或同步方法时，程序调用Thread.sleep().Thread.yield(0方法暂停当前线程的执行,不会释放锁

   案例:上厕所,太困了，在坑位上眯了一会

2. 线程执行同步代码块时，其他线程调用了该线程的suspend(方法将该线程挂起,该线程不会释放锁。

   提示:应尽量避免使用suspend (0和resume()来控制线程,方法不再推荐使用

章节练习题

package Thread;

public class fwork01 {
    public static void main(String[] args) {
        //多线程同步机制卖票
        employ e = new employ();
        new Thread(e).start();
        new Thread(e).start();
        new Thread(e).start();
    }
}
class employ implements Runnable{
    public static int tickets=100;
    static boolean loop=true;
    public synchronized void sell(){
            if (tickets > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                tickets--;
                System.out.println("售卖出一张票" + Thread.currentThread().getName() + "还剩" + tickets + "张票");
            }else{
                System.out.println("售票结束");
                loop=false;
                return;
            }
        }
    @Override
    public void run() {
        while (loop) {
            sell();
        }
    }
}


package Thread;

import java.util.Scanner;

public class work02 {
    public static void main(String[] args) {
        //第一题
//        (1)在main方法中启动两个线程
//        (2)第1个线程循环随机打印100以内的整数
//        (3)直到第2个线程从键盘读取了“Q”命令。
        A a=new A();
        B b=new B(a);
        a.start();
        b.start();
    }
}
class A extends Thread{
    boolean loop=true;
    @Override
    public void run() {
        while(loop){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Math.random()*100+1);
        }
    }
}
class B extends Thread{
    A a;
    public B(A a){
        this.a=a;
    }

    @Override
    public void run() {
        while(true){
            Scanner input=new Scanner(System.in);
            System.out.println("请输入停止指令：");
            String  cc=input.next();
            char c=cc.charAt(0);
            if (c=='Q'){
                a.loop=false;
                break;
            }
        }
    }
}