多线程的创建、同步

最新推荐文章于 2024-08-17 00:13:36 发布
最新推荐文章于 2024-08-17 00:13:36 发布
阅读量547 收藏
点赞数 2
分类专栏： 笔记 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ht_vIC/article/details/113352981
版权

多线程的创建和同步

线程的六种状态

新建(NEW)

至今尚未启动的线程处于这种状态。

可运行(RUNNABLE)

一旦调用start()方法，线程就处于可运行（RUNNABLE）状态。一个可运行的状态可能正在运行也可能没有运行，由操作系统为线程提供具体的运行时间。

终止(TERMINATED)

已退出的线程处于这种状态。

等待(WATING)

当线程等待另一个线程通知调度器出现一个条件时，这个线程会进入等待状态。

计时等待(TIMED_WATING)

等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态，这一状态一直保持到超时期满或者接收到适当的通知。

阻塞(BLOCKED)

受阻塞并等待某个监视器锁的线程处于这种状态，失去了CPU的执行权

线程的生命周期

在这里插入图片描述

线程的创建

继承Thread类

package com.ht.thread;

class demo1 extends Thread{
    @Override
    public void run() {
        super.run();
        for(int i = 0; i < 100; i++){
            if(i % 2 == 0){
                System.out.println(getName() + ": " + i);
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        demo1 d1 = new demo1();
        d1.start();

        for(int i = 0; i < 100; i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

实现Runnable接口

package com.ht.thread;
class demo2 implements Runnable{
    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        demo2 d2 = new demo2();
        Thread t = new Thread(d2);
        t.start();

        for(int i = 0; i < 100; i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

还有一种方法使用lambda表达式

package com.ht.thread;

public class Test {
    public static void main(String[] args) {
		Runnable r = () -> {
            for (int i = 0; i < 100; i++) {
                if (i % 2 == 0) {
                    System.out.println(Thread.currentThread().getName() + ": " + i);
                }
            }
        };
        Thread t = new Thread(r);
        t.start();
        for(int i = 0; i < 100; i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

实现Callable接口

Callable接口与Runnable接口的区别
1.call()有返回值,FutureTask类中的get()方法可以获取返回值
2.call()可以抛出异常
3.Callable支持泛型

package com.ht.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class PrintNumber implements Callable {

    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
        return null;
    }
}

public class CallableTest {
    public static void main(String[] args) {
    	//创建Callable接口实现类的对象
        PrintNumber n1 = new PrintNumber();
        //将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask task = new FutureTask(n1);
        //将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        Thread t = new Thread(task);
        t.start();
    }
}

使用线程池创建线程

package com.ht.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

class PrintNumber implements Callable {

    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
        return null;
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        ThreadPoolExecutor service = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
        service.submit(new PrintNumber());
        service.shutdown();
    }
}

使用一下两个方法启动线程，线程使用完需要使用shutdown()方法关闭线程池
在这里插入图片描述

线程的同步

同步代码块

synchronized(同步监视器){
	//需要同步的代码
}
[同步监视器]:锁。任何一个类的对象都可以充当锁
注意：必须保证多个线程共用同一把锁

继承Thread类的写法

package com.ht.thread;

class Window1 extends Thread{
    private static int tickets = 100;
    private static Object obj = new Object();   //为了保证使用同一把锁，所以使用static进行修饰，此时对象对类的对象
    @Override
    public void run() {
        while(true){
            synchronized(obj) {
                if (tickets > 0) {
                    System.out.println(getName() + "出售车票" + "  票号:" + tickets);
                    tickets--;
                } else {
                    break;
                }
            }
        }
    }

}
public class WindowTest {
    public static void main(String[] args) {
        Window1 w1 = new Window1();
        Window1 w2 = new Window1();
        w1.setName("窗口1");
        w2.setName("窗口2");
        w1.start();
        w2.start();
    }
}

实现Runnable接口的写法

package com.ht.thread;

class Window2 implements Runnable{
    private int tickets = 100;
    @Override
    public void run() {
        while(true){
            synchronized(this) {
                if (tickets > 0) {
                    System.out.println(Thread.currentThread().getName() + "出售车票" + "  票号:" + tickets);
                    tickets--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 w = new Window2();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t1.start();
        t2.start();
    }
}

同步方法

同步方法就是把要同步的代码单独写到一个方法中去，这个方法使用synchronized修饰

继承Thread方法

package com.ht.thread;

class Window1 extends Thread{
    private static int tickets = 100;
    @Override
    public void run() {
        while(true){
            if(tickets <= 0){
                break;
            }
            show();
        }
    }

    public static synchronized void show(){  //使用static修饰保证是同一把锁
        if (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + "出售车票" + "  票号:" + tickets);
            tickets--;
        }
    }
}
public class WindowTest {
    public static void main(String[] args) {
        Window1 w1 = new Window1();
        Window1 w2 = new Window1();
        w1.setName("窗口1");
        w2.setName("窗口2");
        w1.start();
        w2.start();
    }
}

实现Runnable接口

package com.ht.thread;
class Window2 implements Runnable{
    private int tickets = 100;
    @Override
    public void run() {
        while(true){
            if(tickets <= 0){
                break;
            }
            show();
        }
    }

    public synchronized void show(){
        if (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + "出售车票" + "  票号:" + tickets);
            tickets--;
        }
    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 w = new Window2();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t1.start();
        t2.start();
    }
}

同步锁

package com.ht.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;

class demo4 implements Runnable{
    private int num = 100;
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try {
                lock.lock();
                if(num > 0){
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + ": " + num);
                    num--;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(3);
        var d1 = new demo4();
        service.execute(d1);
        service.execute(d1);
        service.execute(d1);
        service.shutdown();

    }
}

Lock和synchonized的区别
synchronized在执行完相应同步代码后，会自动释放同步监视器
Lock需要手动的启动同步(lock())和结束同步(unlock())

ht巷子
关注
专栏目录
多线程的创建和同步
qimojun的博客
05-31 354
线程的创建 Java 虚拟机的主线程入口是 main 方法，用户可以自己创建线程，创建方式有两种： 继承 Thread 类 实现 Runnable 接口（推荐使用 Runnable 接口） 继承 Thread 类 Thread 类中创建线程最重要的两个方法为： public void run() public void start() 采用 Thread 类创建线程，用户只需要继承 Thread，覆盖 Thread 中的 run 方法，父类 Thread 中 的 run 方法没有抛出异常，那么子类也不能抛出
C#多线程及同步示例简析
01-20
60年代，在OS中能拥有资源和独立运行的基本单位是进程，然而随着计算机技术的发展，进程出现了很多弊端，一是由于进程是资源拥有者，创建、撤消与切换存在较大的时空开销，因此需要引入轻型进程；二是由于对称多处理...
多线程创建及同步
快乐学术猿
08-14 282
目录线程与进程Thread的常见方法线程的生命周期多线程的创建继承Thread类代码实施实现Runnable类代码实施实现Callable类代码实施使用线程池代码实施线程安全与同步synchronized同步代码块实现Runnable接口继承Thread类同步方法继承Thread类实现Runnable接口Lock单例设计模式之懒汉式（线程安全） 线程与进程 **进程：**在计算中，进程是由一个或多个线程执行的计算机程序的实例。它包含程序代码及其活动。取决于操作系统（OS），一个进程可能由多个并行执行指令
Java中的线程创建和同步快速入门（保姆级教程）
最新发布
流水悠然，任山川引路。
08-17 1113
当 Java 程序启动时，它会创建一个主线程（main线程），并可能会启动其他子线程。程序会等待所有用户线程完成后才会终止。守护线程：与用户线程不同，守护线程是用来在后台执行支持性任务的，当所有用户线程结束时，守护线程会自动终止，不管它是否完成了自己的任务。
多线程的创建及线程同步
qq_30221329的博客
07-24 112
ee
线程的控制与同步
CONSOLE11的博客
09-28 346
一、线程的生命周期 新建、就绪、运行、阻塞、死亡5种状态 使用new创建线程时处于新建状态（JVM为其分配内存，初始化变量），start时线程处于就绪状态（JVM为其创建方法调用栈和程序计数器）。 启动线程的方法是调用start()方法，而不是run(）方法，若调用run()方法，则会把run()方法当其一般方法执行。并且在调用了run方法后，线程不在处于新建状态， 再去调用start（）
java多线程1-多线程创建与线程同步
面对未来，乘风破浪
04-18 1101
Java多线程与线程同步在Java中实现多线程通过以下2种方式： 1)实现implements 接口Runnable 2) 继承extends Java提供的类Thread，并重写方法run() 一般通过第一种方式来创建多线程.import org.junit.Test; class Work implements Runnable { @Override public voi
QT 多线程同步QSemaphore
11-26
QT框架中的多线程同步是实现高效并发编程的关键技术，其中`QSemaphore`是一个重要的工具。`QSemaphore`是Qt的并发类库中的一员，它主要用于控制对共享资源的访问，实现线程间的同步和互斥。理解并熟练运用`...
java多线程代码案例(创建线程,主线程,线程优先级,线程组,线程同步,线程间的通信)
03-31
本文将深入探讨Java多线程中的关键知识点，包括创建线程、主线程、线程优先级、线程组、线程同步以及线程间的通信。 1. **创建线程** 在Java中，可以通过两种方式创建线程：继承`Thread`类或实现`Runnable`接口。...
Python利用多线程同步锁实现多窗口订票系统(推荐)
12-23
在本文中，我们将深入探讨如何使用Python的多线程和同步锁来实现一个多窗口订票系统，以此防止并发问题，如一票多卖或无票也卖。首先，我们需要了解多线程的基本概念。 **多线程**： 多线程是指在一个程序中同时...
3种多线程实现同步方法
04-03
然而，多线程也带来了数据同步的问题，因为多个线程可能同时访问共享资源，如果不加以控制，就可能导致数据不一致或引发错误。本篇文章将深入探讨三种在C++中实现多线程同步的方法：事件对象、关键代码段和互斥对象...
线程创建方式和线程同步
博客
01-18 1031
一：创建线程方式：1.  继承Thread，然后重写run()方法例如： public class ThreadOne extends Thread {    @Override    public void run() {        Log.i("TAG","创建线程方式1");    }}启动线程方式start ThreadOne one = new ThreadOne();       ...
Linux十一（线程的创建与同步）
程序员的规则
01-27 1263
线程的创建与同步1.线程的概念与实现方式1.1 线程的概念1.2 线程的实现方式1.3 进程与线程的区别2.线程使用3.线程同步4.线程安全5.线程与fork 1.线程的概念与实现方式 1.1 线程的概念 线程：进程内部的一条执行路径，调度的基本单位，一个进程可以包含多个线程。 进程：一个正在运行的程序。动态，资源分配基本单位。 1.2 线程的实现方式 线程实现方式:用户 内核 组合 用户级:不管用户空间线程数目多少，内核空间只提供一个处理器(线程库管理，创建开销小，不能使用多个处理器) 内核级:用户
线程的四种创建方式和三种同步方式
ExceptionCoder的博客
07-24 351
创建方式 一、继承Thread类 步骤： 1、写一个线程类XxxThread extends Thread类 2、重写run()方法 3、写一个测试类，在测试类中创建线程对象—>调用对象的start()启动线程 二、实现Runnable接口 步骤： 1、写一个实现业务类XxxRunnableImpl implements Runnable接口 2、重写run()方法 3、写一个测试类，在测试类中先创建业务类对象—>再创建线程对象—>将业务类对象作为参数传入线程的构造方法中—>调用线程
多线程（线程的概述，创建线程，控制线程，线程同步，线程池）
dajiahuooo的博客
07-23 436
1.线程的概述 线程是：当一个程序运行时，内部可能包含了多个顺序的执行流，每个执行流就是一个线程。 线程与进程的区别：进程有独立的内存空间地址，线程共享内存空间地址                   进程是静态的指令集，线程是动态的指令集                   进程并行
多线程的创建与同步
男人要霸气的博客
08-29 239
下面咱们来了解下什么是多线程？ 思考 : 能否在同一个Java应用程序中执行2个以上的无限循环呢? 1.1什么是多线程？ 是指一个应用程序中有多个线程并发执行。 1.2并发： 通过CPU的调度算法，使用户感觉像是同时处理多个任务，但同一时刻只有一个执行流占用CPU执行。即使多核多CPU环境还是会使用并发，以提高处理效率。（切换执行） 多线程技术并不能直接提高程序的...
实现线程同步的方法和实现多线程
qq_36335126的博客
08-20 380
一、 实现线程同步 1.同步方法 即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时， 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。 2.同步代码块 即有synchronized关键字修饰的语句块。 被该关键字修饰的语句块会自动被加上内置锁，从而实现同步 代码如： synchronized(object){ } 注：同步是一种高开销的操作，因此应该尽量减少同步的内容。 通常没有必要同步整个方法，使用synchronize
Java怎么实现线程同步？
leiyu的博客
05-13 670
Java线程同步  在之前的文章《Java的Thread类的两种实现方式的区别》中，我们发现，通过实现Runnable接口创建的线程可能会出现被共享的资源，被多个线程同时操作，并导致数据不准确的现象，那我们怎么去保护我们的敏感数据的，必须让共享的数据在一个特定的操作时间内只能由一个线程来进行操作，这，便是线程同步的概念。  首先来看一下不同步时的代码： //Bank public class Bank { private int money = 0; pub
创建线程的四种方法和线程同步的三种方式
qq_43883961的博客
07-01 526
今天来总结一下创建线程的四种方法：继承Thread类、实现Runnable接口、实现Callable接口、线程池以及线程同步的三种方式 一、继承Thread类 重写run()方法，创建实例化对象，调用start()方法 匿名内部类实现 注意：继承Thread类创建线程时定义变量时要加上static关键字，这样才能保证多个线程使用同一个变量 二、实现Runnable接口 1、创建一个实现了Runnable接口的类 2、重写run()方法 3、创建类的实例化对象 4、创建Thread类的实例化对象并将t
Java多线程编程详解：线程创建与同步
"这篇文档是关于多线程学习的笔记，涵盖了线程与进程的区别、线程的三种创建方式以及线程同步和生产者消费者模式等核心概念。" 在计算机科学中，进程和线程是操作系统中的两个基本概念。一个进程可以被视为一个独立...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ht巷子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值