线程

最新推荐文章于 2022-12-20 19:24:59 发布
最新推荐文章于 2022-12-20 19:24:59 发布
阅读量125 收藏 1
点赞数 1
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guibar/article/details/111025344
版权
并发和并行

并发:指的是两个或者多个事件(任务)在同一时间段内发生的。

并行:指的是两个或者多个事件(任务)在同一时刻发生(同时发生)。

在这里插入图片描述

线程与进程

进程:是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个线程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序就是一个进程从创建、运行到消亡的过程。

线程:线程是进程中的一个执行单元，负责当前进程中程序的运行，一个程序中至少有一个线程。一个进程可以有多个线程，这个应用程序也可以称之为多线程程序。

简而言之，一个程序运行后至少有一个进程，一个进程中可以包含多个线程。

备注:单核处理器的计算机肯定不能并行的处理多个任务的，只能是多个任务在单个cpu上并发的执行。同理，线程也是一样的，从宏观角度上理解线程是一种并行运行的，但是从微观上分析并行运行不可能，即需要一个一个线程的去执行，当系统只有一个cpu的时候，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

线程调度：

  • 分时调度：所有的线程轮流使用CPU的使用权，平均分配给每个线程占用CPU的时间
  • 抢占式调度：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机一个线程 执行，Java使用的就是抢占式调度方式来运行线程程序。
    • 设置线程的优先级
创建线程类

java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或者Thread类的子类的实例。每个线程的作用是完成一定的程序，实际上就是执行一段程序流，java使用线程执行体来代表折断程序流。

java中通过继承Thread类来创建并启动多线程，步骤如下:

package com.zhiyou100.thread2;
/*
   创建多线程程序的第一种方式:创建Thread类的子类
   java.lang.Thread类,是描述线程的类,我们想要实现多线程程序,就必须继承Thread类

   实现步骤:
    1.创建一个Thread类的子类
    2.在Thread类的子类当中重写Thread类的run方法,设置线程任务(开启线程需要你做什么事情?)
    3.创建Thread类的子类对象
    4.调用Thread类中的方法start方法,开启新线程,执行run方法
       void start() 使该线程开始执行:Java 虚拟机调用该线程的run方法。
       结构式两个线程并发地运行,当前线程(从调用返回给start方法)和另一个线程(执行其run方法)。
       多次启动一个线程是非法的。特别是当线程已经结束执行后,不能再重新启动。
    Java程序属于抢占式调度，哪个线程的优先级高，哪个线程就优先执行，同一个优先级的线程，系统就随机一个线程执行。
 */
public class Demo01Thread {
    public static void main(String[] args) {
        // 3.创建Thread类的子类对象
        MyOneThread oneThread = new MyOneThread();
        // 4.调用Thread类中的方法start方法,开启新线程,执行run方法
        oneThread.run();
        oneThread.start();
        new MyOneThread().start();

        // 在主线程中循环20次,打印循环的次数
        for (int i = 0; i < 20; i++) {
            System.out.println("main:--->" + i);
        }

    }
}

package com.zhiyou100.thread2;

public class MyOneThread extends Thread{
   //2.在Thread类的子类当中重写Thread类的run方法,设置线程任务

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run:---->" + i);
        }
    }
}
多线程的原理

如图为多线程的执行流程
在这里插入图片描述

程序启动运行main的时候，java虚拟机启动了一个进程，主线程main在main调用的时候被创建。随着调用oneThread对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程环境下运行者。

通过上面一张图可以发现多线程在内存当中的执行流程。

多个线程执行时，在栈内存当中，其实每一个线程都有一片属于自己的栈内存空间，进行方法的压栈和弹栈。

当执行线程的任务结束了，线程自动在栈内存当中释放了。当所有的执行线程都结束了，那么进程也就结束了。

Thread类

API帮助文档中定义了有关线程的一些方法，具体如下:

构造方法:

public Thread(): 分配一个新的线程对象

public Thread(String name): 分配一个指定名字的新的线程对象

public Thread(Runnable target): 分配一个带有指定目标新的线程对象

public Thread(Runnable target,String name): 分配一个带有指定目标的新的线程对象并且带有指定名字

常用的方法:

public String getName(): 获取当前线程的名称

public void start(): 让此线程开始执行，java虚拟机会调用此线程的run方法

public void run(): 此线程要执行的任务在此方法内定义

public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停(临时性暂停线程的执行)

package com.zhiyou100.thread5;
/*
  public static void sleep(long mills) 在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)

 */
public class Demo01SleepThread {

    public static void main(String[] args) {
        // 模拟秒表计时器 一秒一秒的走

        for (int i = 1; i <= 60; i++) {
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

}

public static Thread currentThread(): 获取当前正在执行的线程对象的引用

通过翻阅API得知，创建线程有有两种方式，一种使继承Thread类，一种是实现Runnable接口

创建线程方式二

采用java.lang.Runnable也是非常常见的一种,我们只需要重写run方法即可

步骤如下:

1.定义Runnable接口的实现类，并重写该接口的run方法，该方法的方法体同样是该线程的线程执行体。

2.创建Runnable接口实现类的实例，并以此实例作为Thread类的target来创建Thread类的对象，该Thread类的对象才是真正的线程对象。

3.调用线程对象的start()方法来启动新线程。

通过实现Runnable接口，使得该类有了多线程类的特征，run方法是多线程程序的一个执行目标，所有的多线程代码都写在run()方法中，Thread类实际上也是实现了Runnable接口的类

在启动多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target)构建线程对象，然后调用Thread类对象的start方法来运行多线程程序。

备注:Runnable对象仅仅作为Thread类对象的target，Runnable实现类里包含了run方法作为线程的执行体。而实际的线程对象依然是Thread类的实例。

package com.zhiyou100.thread6;
/*
  创建多线程程序的第二种方式,实现Runnable接口
  java.lang.Runnable
   Runnable接口应该由那些打算通过某一线程执行其实例的类来实现，类必须定义一个称为run的无参数方法
  java.lang.Thread
   Thread(Runnable target):分配新的Thread类的对象
   Thread(Runnable target,String name):分配新的Thread类的对象
  实现步骤:
     1.定义一个Runnable接口的实现类
     2.在实现类中重写Runnable接口当中的run方法,设置线程任务
     3.创建Runnable接口的实现类对象
     4.构建Thread类的对象,在构造方法中传递Runnable接口的实现类对象
     5.调用Thread类中的start方法,开启新线程执行run方法
  实现Runnable接口创建多线程程序的好处:
     1.避免了单继承的局限性
     一个类只能直接继承一个父类,类继承了Thread类就不能继承其他的类
     实现Runnable接口,还可以继承其他的类,还可以实现其他的接口
     2.增强了程序的扩展性,降低了程序的耦合性(解耦)
     实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)
     实现类中,重写了run方法,用来设置线程的任务
     创建Thread类的对象,调用start方法,用来开启新的线程
 */
public class Demo01Runnable {

    public static void main(String[] args) {
        // 3.创建Runnable接口的实现类对象
        Runnable runnable = new Demo02RunnableImpl(); // 多态
        // 4.构建Thread类的对象,在构造方法中传递Runnable接口的实现类对象
        Thread thread = new Thread(runnable);
        // 5.调用Thread类中的start方法   开启新线程执行run方法
        thread.start();

        // 采用匿名对象调用start方法
        new Thread(new Demo03RunnableImpl()).start();

        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);

        }

    }


}

package com.zhiyou100.thread6;
//1.定义一个Runnable接口的实现类
public class Demo02RunnableImpl implements Runnable{

     // 2.在实现类中重写Runnable接口当中的run方法，设置线程任务
    @Override
    public void run() {
        // 循环20次 打印循环的次数
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

package com.zhiyou100.thread6;

public class Demo03RunnableImpl implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "HelloWorld!");
        }
    }
}
Thread类和Runnable接口的区别

如果一个类继承了Thread类，则不适合资源的共享。但是如果实现了Runnable接口的话，则很容易实现资源共享。

实现Runnable接口比继承Thread类的所具有的优势:

1.适合多个相同的程序代码的线程取共享同一个资源

2.可以避免java中单继承的局限性

3.增加了程序的扩展性，实现解耦操作，代码可以被多个线程共享，代码和线程可以实现分离

4.线程池只能放入实现Runnable或者Callable类的线程，不能直接放入继承Thread的类

备注:在java中，每次程序运行至少启动两个线程，一个是main线程，一个是垃圾收集线程。因为每当使用java命令去执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实都是在操作系统中启动了一个进程。

匿名内部类方式实现多线程程序的创建

使用线程的匿名内部类方式，可以很方便的实现每个线程执行不同的线程任务操作。

使用匿名内部类方式实现Runnable接口的run方法。

示例代码:

public static void main(String[] args) {
		// 创建线程对象
		//new Thread().start();
		new Thread() {
			// 重写run方法
			@Override
			public void run() {
				// 循环20次，打印循环的次数
				for (int i = 0; i < 20; i++) {
					System.out.println(Thread.currentThread().getName() + "--->" + i);
				}
			}
		}.start();
		// 线程的接口Runnable
	    Runnable run = new Runnable() {
	    	// 重写run方法
	    	@Override
	    	public void run() {
	    		// 循环20次，打印循环的次数
				for (int i = 0; i < 20; i++) {
					System.out.println(Thread.currentThread().getName() + "--->" + i);
				}
	    	}
	    };
		new Thread(run).start();
		// 简化接口的方式
		new Thread(new Runnable() {
			// 重写run方法
			@Override
			public void run() {
				// 循环20次，打印循环的次数
				for (int i = 0; i < 20; i++) {
					System.out.println(Thread.currentThread().getName() + "--->" + i);
				}
			}
		}).start();
线程安全

如果有多个线程在同时运行，而这些线程可能同时在运行这些代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的值是一样的，就是线程安全的。

package com.zhiyou100.thread8;

public class RunnableImpl implements Runnable{
    // 定义一个多线程可以共享的资源 票
    private int ticket = 100;
    // 设置线程的任务,卖票  此时窗口 --->线程
    @Override
    public void run() {
        // 如果票存在
            while (ticket > 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "---->正在售卖第" + ticket + "张票");
                ticket--;
            }

    }


}

package com.zhiyou100.thread8;
/*
 模拟卖票
 创建3个线程(窗口),同时开启,对共享的票进行售卖
 */
public class SaleTicketDemo {
    public static void main(String[] args) {
        // 创建Runnable接口的实现类对象
        Runnable run01 = new RunnableImpl();
        // 创建Thread类的对象,构造方法中传递Runnable接口的实现类对象
        new Thread(run01).start();
        new Thread(run01).start();
        new Thread(run01).start();

    }
}

通过上面的案例发现，当多个线程去共享同一个资源的时候出现了线程的不安全的问题

1.相同的票数，被卖了多少次

2.不存在的票，也被卖出去了，比如说0和-1

在这里插入图片描述

这种问题，几个窗口(线程)票数不同步，这种问题我们称之为线程不安全

备注：线程安全问题一般都是由全局变量或者静态变量引起的，若每个线程中对全局变量、静态变量只有读操作，而无写的操作，这样的话，这个全局变量就是线程安全的；若有多个线程同时执行写操作，一般就需要考虑线程的同步，否则的话就很可能会引发线程的安全问题。

线程的同步

当我们使用多线程访问同一资源的时候，且这多个线程中对资源有写的操作，就容易出现线程安全问题。

要解决多线程并发访问一个资源的安全问题，java中提供了同步机制(synchronized)来解决。

窗口1线程进入操作的时候，窗口2和窗口3线程只能在外面等着，当窗口1线程操作结束，窗口1和窗口2和窗口3才有机会进入代码中去执行。也就是说某个线程修改共享资源的时候，其他线程不能修改共享资源，等待修改完毕同步后，才能去抢夺cpu的使用资源，完成对应的操作，保证了数据的同步性。解决了线程不安全的问题。

package com.zhiyou100.thread9;

/*
   此时卖出了重复的票和不存在的票
   解决线程安全性问题的第一种方案:--->使用同步代码块
   格式:
        synchronized(锁对象){
          可能出现线程安全问题的代码(访问了共享的数据)
        }
   注意:
      1.通过代码块中的锁对象,可以使用任意类型的对象
      2.但是必须保证多个线程使用的锁对象是同一把锁
      3.锁对象的作用:
         把同步代码块锁住,只有一个线程在同步代码块中执行
 */
public class RunnableImpl implements Runnable {
    // 定义一个多线程可以共享的资源 票
    private int ticket = 1000;
    // 创建一个锁对象
    Object obj = new Object();

    // 设置线程的任务,卖票  此时窗口 --->线程
    @Override
    public void run() {
        // 如果票存在
        while (true) {
            synchronized (obj) {
                if (ticket > 0) {
                   /* try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }*/
                    System.out.println(Thread.currentThread().getName() + "---->正在售卖第" + ticket-- + "张票");

                }
            }
        }
    }


}

package com.zhiyou100.thread9;

public class SaleTicketDemo {
    public static void main(String[] args) {
        // 创建Runnable接口的实现类对象
        Runnable run = new RunnableImpl();
        // 创建Thread类的对象,构造方法中传递Runnable接口的实现类对象
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        Thread t3 = new Thread(run);
        t1.start();
        t2.start();
        t3.start();

    }
}

有三种方式实现同步机制:

1.同步代码块

2.同步方法

3.锁机制

同步代码块

同步代码块:synchronized关键字可以用于方法中的某个代码块中，表示只对这个代码块的资源实行互斥访问。

格式:

synchronized(同步锁) {
    // 需要同步操作的代码。
}
同步锁

同步锁是一个对象，是一个抽象的概念，可以想象成在对象上标记了一个锁。

1.锁对象可以是任意类型的 Object

2.多个线程对象，要使用同一把锁

注意:在任何时候，最多允许一个线程拥有同步锁，谁拿到同步锁谁就拥有资格进入代码块中，其他线程只能在外面等候着。(Blocked阻塞状态)

同步原理图解:
在这里插入图片描述

guibar
关注
通过Stack Overflow线程栈溢出的问题实例，详解C++程序线程栈溢出的诸多细节
dvlinker的技术专栏
08-04 1万+
通过Stack Overflow线程栈溢出的问题实例，详解C++程序线程栈溢出的诸多细节
Linux 多线程原理深剖
最新发布
qq_61500888的博客
12-24 4万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
Thread线程
AmyZheng_的博客
08-07 577
1、什么是线程？ 线程( Thread ) 被称作轻量级进程( Lightweight Process )，线程是比进程更小一级的执行单元。 一个进程可以有多个线程，但至少有一个线程（当进程被初始化后，主线程也就被创建了）。 2、如何实现线程？ 继承Tread类。 实现Runnable接口。 3、Thread 类中的start() 和 run() 方法有什么区别？ start()方法被用...
线程知识点总结
weifeng的博客
04-07 1102
知识是什么，知识就是看完了书把书扔掉之后脑中那些清晰、准确、必要的概念。 之前也写了挺多关于线程的博客，但是由于自己基础不扎实，大多数都是摘录别人的东西。所以这篇文章就是对一些重要的概念进行总结，把知识归纳整理，这篇博客会长期更新，只要遇到了一些自己不懂而且重要的理论就会添加上去。 进程优先级的5种类型：前台进程、可见进程、服务进程、后台进程、空进程1、前台进程 （Foreground p
线程知识点
m0_58103348的博客
07-16 150
java线程
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
线程知识点（笔记）
qq_40796888的博客
10-19 3322
线程知识点（笔记） 线程 synchronized和Lock锁的区别？ 1.存在层次上，synchronized是Java的关键字，在jvm层面上；而Lock是一个类 2.锁的释放上，synchronized是 1、以获取锁的线程执行完同步代码，释放锁 2、线程执行发生异常，jvm会让线程释放锁； 而Lock是在finally中必须释放锁(lock.unlock())，不然容易造成线程死锁 3.锁的获取上，synchronized是假设A线程获得锁，B线程等待。如果A线程阻塞，B线程会一直等待； 而Lock
线程相关知识点
qq_45792764的博客
08-09 511
线程相关知识点
线程基本知识点
m0_50959444的博客
02-12 307
1、线程、进程概念理解 线程 线程是cpu独立运行和独立调度的基本单位 线程可以理解为是操作系统中的应用程序（一段代码） 线程是进程中一段可以单独执行的代码，线程可共享进程的内存空间 进程 进程是资源分配的基本单位 进程可以理解为操作系统 当一个程序被加载到内存并且被执行的时候这个程序就成为一个进程（运行中的程序） 线程调度 线程获得cpu时间片，线程才能够执行 线程优先级不同，采用抢占式调度机制，优先级相同时，采用分时调度机制。 java线程与原生操作系统线程有直接的映射关系
线程的基本知识点
吹 梦到西州的博客
12-20 128
多线程和单线程
线程基础知识点
06-20 733
一、概念 进程并不执行任务，只是为线程提供空间和资源，线程才是执行任务的实体。
关于线程知识点
m0_59007351的博客
04-02 379
一。线程概念：是进程的实体，是CPU调度和分配比进程更小的调度单位。 进程：是一个具有独立功能的程序在某个数据集合的一次运行活动，是操作系统进行资源分配和调度的独立单位。 线程小于进程，让多进程有高并发的特性，进程在运行的时候每个单元模块相互独立，线程之间按内存共享，优化用户体验。 二。创建线程的4种方式 1，继承Thread 类重写run方法创建线程，但是不能继承其他类； 2，实现Runnable接口重写run方法，避免单继承（接口方法没有返回值，只能抛出运行时异常无法捕获） 3，实现Call
必必须掌握的线程知识点
最大努力的博客
08-06 1090
java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口 Thread类是在java.lang包中定义的，一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限 详见：http://developer.51cto.com/art/201203/321042.htm 知识点一、实现自定...
线程常见知识点总结
weixin_42281010的博客
06-15 552
进程是程序的一次执行过程，是系统运行程序的基本单位。线程与进程类型，但线程是一个比进程更小的执行单位。一个进程在执行的过程中可以产生多个线程。同类的多个线程共享同一块内存空间和一组系统资源，所以系统产生一个线程或者在各个线程之间进行切换时，负担要比进程小很多，正因如此，线程也被称为轻量级进程。 1.线程的状态 线程在生命周期中可能会处于以下6种状态 线程创建之后会处于新建状态，调用start()方法后先进入就绪状态，在线程获得CPU时间片后就处于运行状态。当线程调用同步方法时，在没有获..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值