正文

java基础之线程

风@太@大  2022-04-26  484

关键词：

一、线程的基本概念

　　程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

　　进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。如：运行中的QQ，运行中的MP3播放器程序是静态的，进程是动态的

　　线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个程序可同一时间执行多个线程，就是支持多线程的。

　　进程与多线程：

　　什么时候需要多线程：

　　1、程序需要同时执行两个或多个任务。

　　2、程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

　　3、需要一些后台运行的程序时。

注意：每个Java程序都有一个隐含的主线程： main 方法

二、线程的创建与运行

　　Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现。

　　Thread类的特性：

　　　　每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体。

　　　　通过该Thread对象的start()方法来调用这个线程。

　　1、Thread类

　　构造方法

　　Thread()：创建新的Thread对象

　　Thread(String threadname)：创建线程并指定线程实例名

　　Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法

　　Thread(Runnable target, String name)：创建新的Thread对象

　　2、创建线程的两种方式

　　（1）、继承Thread类

　　　1)、定义子类继承Thread类。

　　　2) 、子类中重写Thread类中的run方法。

　　　3) 、创建Thread子类对象，即创建了线程对象。

　　　4) 、调用线程对象start方法：启动线程，调用run方法。

public class MyThread extends Thread {
    public void run(){
        for (int a = 1; a < 10; a++){
            System.out.println(Thread.currentThread().getName() + a);
        }
    }
}

public class Test_Thread {
    public static void main(String[] args) {
        for (int a = 1; a < 10; a++){
            System.out.println(Thread.currentThread().getName() + a);//主线程
        }

        MyThread myThread1 = new MyThread();//开启第一个线程
        myThread1.start();

        MyThread myThread2 = new MyThread();//开启第二个线程
        myThread2.start();

        MyThread myThread3 = new MyThread();//开启第三个线程
        myThread3.start();
    }
}

.　　（2）、实现Runnable接口

　　　1）、定义子类，实现Runnable接口。

　　　2）、子类中重写Runnable接口中的run方法。

　　　3）、通过Thread类含参构造器创建线程对象。

　　　4）、将Runnable接口的子类对象作为实际参数传递给 Thread类的构造方法中。

　　　5）、调用Thread类的start方法：开启线程，调用 Runnable子类接口的run方法。

public class MyThread implements Runnable {
    int a = 30;
    @Override
    public void run() {
        for (int i = 0; i < a; i++){
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

public class Test_Thread {
    public static void main(String[] args) {
        for (int a = 0; a < 10; a++){
            System.out.println(Thread.currentThread().getName()+a);//主线程
        }

        MyThread myThread = new MyThread();//创建线程对象

        Thread thread1 = new Thread(myThread);//开启第一个线程
        thread1.start();

        Thread thread2 = new Thread(myThread);//开启第二个线程
        thread2.start();

        Thread thread3 = new Thread(myThread);//开启第三个线程
        thread3.start();
    }
}

　　（3）、实现资源共享

public class Test_Thread {
    public static void main(String[] args) {
        for (int a = 0; a < 10; a++){
            System.out.println(Thread.currentThread().getName() + a);
        }
        MyThread myThread = new MyThread();
        
        Thread thread1 = new Thread(myThread);
        thread1.start();
        thread1.setPriority(Thread.MAX_PRIORITY);

        Thread thread2 = new Thread(myThread);
        thread2.start();

        Thread thread3 = new Thread(myThread);
        thread3.start();
        thread3.setPriority(Thread.MIN_PRIORITY);
    }
}

public class MyThread implements Runnable{
    int a = 10;
    @Override
    public void run() {
        while (true){
            if (a < 0){
                break;
            }
            System.out.println(Thread.currentThread().getName() + a--);
        }
    }
}

　　3、两种创建线程的区别与联系

　（1）、继承Thread: 线程代码存放Thread子类run方法中。实现Runnable：线程代码存在接口的子类的run方法。

　（2）、实现方式创建线程的好处

　　　1）避免了单继承的局限性

　　　2）多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

　　4、Thread类的有关方法

　　（1）、第一类

　　　void start(): 启动线程，并执行对象的run()方法

　　　run(): 线程在被调度时执行的操作 String

　　　getName(): 返回线程的名称

　　　void setName(String name):设置该线程名称

　　　static currentThread(): 返回当前线程

　　（2）、第二类（线程的调度）

　　调度策略：

　　时间片：

　　抢占式：高优先级的线程抢占CPU

　　Java的调度方法：同优先级线程组成先进先出队列（先到先服务），使用时间片策略对高优先级，使用优先调度的抢占式策略

　　线程的优先级控制：

　　MAX_PRIORITY（10）;

　　MIN _PRIORITY （1）;

　　NORM_PRIORITY （5）;

　　涉及的方法： getPriority() ：返回线程优先值

　　setPriority(int newPriority) ：改变线程的优先级线程创建时继承父线程的优先级

　　（3）、第三类

　　　　static void yield()：线程让步暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程若队列中没有同优先级的线程，忽略此方法

　　　　 join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止低优先级的线程也可以获得执行

　　　　static void sleep(long millis)：(指定时间:毫秒) 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。抛出InterruptedException异常

　　　　stop(): 强制线程生命期结束

　　　　boolean isAlive()：返回boolean，判断线程是否还活着

　　5、线程的分类

　　Java中的线程分为两类：一种是守护线程，一种是用户线程。

　　它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。

　　守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。 Java垃圾回收就是一个典型的守护线程。若JVM中都是守护线程，当前JVM将退出。

　　6、为什么要使用多线程

　　背景：只使用单个线程完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？

　　（1）多线程程序的优点：提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

　　（2）提高计算机系统CPU的利用率。

　　（3）改善程序结构，将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

　　7、线程的生命周期

　　要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

　　新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。

　　就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件。

　　运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能。

　　阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态。

　　死亡：线程完成了它的全部工作或线程被提前强制性地中止。

三、线程的同步

　　多个线程执行的不确定性引起执行结果的不稳定多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

　　举个例子：

　　（1）、你的账户上有3000元。有一个存折和一张卡对应的是这一个账户。

　　（2）、你去银行柜台取2000元，存折显示你账户有3000元，柜台员工正在给你办理。但是同时你的老婆在取款机上也取2000元，账户也显示有3000元。这样你们就取出4000元，这是很明显的错误。

　　（3）、解决办法就是，在你取钱的同时，你的账户是不允许有其他人取钱的，你取过钱，你的账户的钱减去2000元后，才能够其他取钱操作（资源独占）。

　　线程安全产生的原因：

　　当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

　　解决办法：

　　对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

package main.dyh.test_two;

class Ticket implements Runnable{
    private static int tick = 100;
    public void run(){
        while(true){
            if(tick>0){
                System.out.println(Thread.currentThread().getName()+"售出车票，tick号为："+ tick--);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                break;
            }
        }
    }
}

class  TicketDemo{
    public static void main(String[] args) {
        Ticket t = new Ticket();
        
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        t1.setName("t1窗口");
        t2.setName("t2窗口");
        t3.setName("t3窗口");

        t1.start();
        t2.start();
        t3.start();
    }
}

　　安全问题的解决：

　　Synchronized的使用方法：

　　　　（1）、synchronized (对象）{

　　　　　　 // 需要被同步的代码；

　　　　 }

　　即有synchronized关键字修饰的方法。
　由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。
　synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类。

　　synchronized还可以放在方法声明中，表示整个方法为同步方法。例如：

　　　　（2）、public synchronized void show (String name){

　　　　　　　　　　　　….

　　　　 }

　　即有synchronized关键字修饰的语句块。
　被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

　　注：同步是一种高开销的操作，因此应该尽量减少同步的内容。
　通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

　　互斥锁：

　　　　在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。

　　　　每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。

　　　　关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。

　　　　同步的局限性：导致程序的执行效率要降低同步方法（非静态的）的锁为this。

　　　　同步方法（静态的）的锁为当前类本身。

package main.dyh.test_two;

class Ticket implements Runnable{
    private static int tick = 100;
    public void run(){
        while(true){
            synchronized (this){
                if(tick>0){
                    System.out.println(Thread.currentThread().getName()+"售出车票，tick号为："+ tick--);
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else
                    break;
            }
        }
    }
}

class  TicketDemo{
    public static void main(String[] args) {
        Ticket t = new Ticket();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        t1.setName("t1窗口");
        t2.setName("t2窗口");
        t3.setName("t3窗口");

        t1.start();
        t2.start();
        t3.start();
    }
}

单例模式之懒汉模式：

class Singleton {
    private static Singleton instance = null;
    private Singleton(){}
    public static Singleton getInstance(){
        if(instance==null){
            synchronized(Singleton.class){
                if(instance == null){
                    instance=new Singleton();
                }    }    }
        return instance;
    }     }
public class TestSingleton{
    public static void main(String[] args){
        Singleton s1=Singleton.getInstance();
        Singleton s2=Singleton.getInstance();
        System.out.println(s1==s2);
    }    }

View Code

四、线程死锁

　　死锁：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

　　解决方法：专门的算法、原则尽量减少同步资源的定义

五、线程通信

　　wait() 与 notify() 和 notifyAll()

　　wait()：令当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问
　　notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
　　notifyAll ()：唤醒正在排队等待资源的所有线程结束等待
　　Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常

　　（1）、wait()

　　在当前线程中调用方法：对象名.wait()
　　使当前线程进入等待（某对象）状态，直到另一线程对该对象发出 notify (或notifyAll) 为止。
　　调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
　　调用此方法后，当前线程将释放对象监控权，然后进入等待
　　在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。

　　（2）、notify()与notifyAll()

　　在当前线程中调用方法：对象名.notify()
　　功能：唤醒等待该对象监控权的一个线程。
　　调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

　　经典案例：生产者消费者问题

　　生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

　　这里可能出现两个问题：

　　生产者比消费者快时，消费者会漏掉一些数据没有取到。

　　消费者比生产者快时，消费者会取相同的数据。

package main.dyh.test_two;

public class TestProduct {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Thread productorThread = new Thread(new Productor(clerk));
        Thread consumerThread = new Thread(new Consumer(clerk));
        productorThread.start();
        consumerThread.start();
    }
}

class Clerk{  //售货员
    private int product = 0;
    public synchronized void addProduct(){
        if(product >= 20){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            product++;
            System.out.println("生产者生产了第"+product+"个产品");
            notifyAll();
        }
    }
    public synchronized void getProduct(){
        if(this.product <= 0){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            System.out.println("消费者取走了第"+product+"个产品");
            product--;
            notifyAll();
        }
    }
}

class Productor implements Runnable{  //生产者
    Clerk clerk;
    public Productor(Clerk clerk){
        this.clerk = clerk;
    }
    public void run(){
        System.out.println("生产者开始生产产品");
        while(true){
            try {
                Thread.sleep((int)Math.random()*1000);
            } catch (InterruptedException e) {
            }
            clerk.addProduct();
        }
    }
}

class Consumer implements Runnable{  //消费者
    Clerk clerk;
    public Consumer(Clerk clerk){
        this.clerk = clerk;
    }
    public void run(){
        System.out.println("消费者开始取走产品");
        while(true){
            try {
                Thread.sleep((int)Math.random()*1000);
            } catch (InterruptedException e) {
            }
            clerk.getProduct();
        }
    }
}

java基础之多线程闭锁

1.闭锁方式1：利用CountDownLatch进行闭锁importjava.util.concurrent.CountDownLatch;publicclassCloseLock3{ publicstaticvoidmain(String[]args){ longstart=System.currentTimeMillis(); CountDownLatchlatch=newCountDow 查看详情

java基础之线程的交互

voidnotify() 唤醒在此对象监视器上等待的单个线程 voidnotifyAll() 唤醒在此对象监视器上等待的所有线程 voidwait() 导致当前的线程等待，直到其他线程调用此对象的 notify()方法或... 查看详情

java基础之线程

进程与线程进程：进程是指内存中运行得一个程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程是程序运行的一次过程，是系统运行程序的基本单位。线程：进程内部以个单独的独立执行单元... 查看详情

java多线程基础之任务调度

*Timer:任务调度 *schedule(TimerTasktask,Datetime); *schedule(TimerTasktask,Date *firstTime,longperiod); *TimerTask实现了Runnable接口；也是一个线程可以了解一下QUQRTZ框架 publicclassTime{ publicstaticv 查看详情

java并发编程系列之二线程基础

上篇文章对并发的理论基础进行了回顾，主要是为什么使用多线程、多线程会引发什么问题及引发的原因，和怎么使用Java中的多线程去解决这些问题。正所谓，知其然知其所以然，这是学习一个知识遵循的原则。推荐读者先行... 查看详情

java并发专题之二java线程基础

使用线程更好的提高资源利用率，但也会带来上下文切换的消耗，频繁的内核态和用户态的切换消耗，如果代码设计不好，可能弊大于利。一、线程　　进程是分配资源的最小单位，线程是程序执行的最小单位；线程是依附于进... 查看详情

java基础学习——多线程之线程池

1.线程池介绍线程池是一种线程使用模式。线程由于具有空闲（eg：等待返回值）和繁忙这种不同状态，当数量过多时其创建、销毁、调度等都会带来开销。线程池维护了多个线程，当分配可并发执行的任务时，它... 查看详情

java基础之（十四）--“多线程”

菜鸟里写的暂时够用了，菜鸟不充点：如果只想重写run()方法，而不重写其他Thread方法，那么应使用Runnable接口。这很重要，因为除非程序员打算修改或增强类的基本行为，否则不应为该类创建子类【java的api建议】菜鸟中只有前... 查看详情

java基础学习——多线程之创建任务

这次来盘点一下Java中用线程执行任务的写法。1.扩展Thread 最基本的实现方法是在创建一个继承Thread的新类，在其中覆盖run()方法执行任务。1publicclassMyThreadextendsThread{2//变量3privateStringname="";4//构造函数5publicMyThrea... 查看详情

java基础之线程阻塞队列

阻塞队列是Java线程新特征中的内容，Java定义了阻塞队列的接口java.util.concurrent.BlockingQueue，阻塞队列的概念是，一个指定长度的队列，如果队列满了，添加新元素的操作会被阻塞等待，直到有空位为止。同样，当队... 查看详情

java基础之线程

一、线程的基本概念　　程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。　　进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存... 查看详情

java基础之线程原子量

所谓的原子量即操作变量的操作是“原子的”，该操作不可再分，因此是线程安全的。为何要使用原子变量呢，原因是多个线程对单个变量操作也会引起一些问题。在Java5之前，可以通过volatile、synchronized关键... 查看详情

java多线程系列---“基础篇”07之线程休眠

转自：http://www.cnblogs.com/skywang12345/p/3479256.html （含部分修改）概要本章，会对Thread中sleep()方法进行介绍。涉及到的内容包括： sleep()介绍 sleep()示例 sleep()与wait()的比较一.sleep()介绍sleep()定义在Thread.java中。slee 查看详情

java多线程系列---“基础篇”06之线程让步

转自：http://www.cnblogs.com/skywang12345/p/3479243.html （含部分修改）概要本章，会对Thread中的线程让步方法yield()进行介绍。涉及到的内容包括：yield()介绍yield()示例yield()与wait()的比较一.yield()介绍yield()的作用是让步。... 查看详情

java基础之线程的两种实现方式

进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程！线程总是属于某个线程，进程中的线程共享进程的内存注意：对Java来说，run()方法没有任何特... 查看详情

java基础之线程阻塞栈

阻塞栈，与阻塞队列相似。不同点在于栈是“后入先出”的结构，每次操作的是栈顶，而队列是“先进先出”的结构，每次操作的是队列头；Java为阻塞栈定义了接口：java.util.concurrent.BlockingDeque，其实现... 查看详情

java基础之线程新特性条件变量

条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的，这样，条件就和一个锁对象绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控... 查看详情

java基础之线程9-cpuvolatile

cpuvolatile和上一篇javavolatile不一样。cpu是如何保证各内存之间数据可见性的呢？答：缓存一致性协议(MESIcache)。 cacheline：cpu缓存行，多大呢64b字节查看详情