扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >学习java多线程
  • 323

0
分享到

学习java多线程

2024-04-02 19:04:59 323人浏览 安东尼

Python 官方文档：入门教程 => 点击学习

摘要

目录介绍为什么需要多线程线程状态转换线程使用方式继承 Thread 类实现 Runnable 接口实现 Callable 接口同步代码---Runnable接口方式同步方法--Run

介绍

程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程。——生命周期
　　>如:运行中的QQ，运行中的MP3播放器
　　>程序是静态的，进程是动态的
　　>进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小；
一个进程中的多个线程共享相同的内存单元/内存地址空间→它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

为什么需要多线程

众所周知，CPU、内存、I/O 设备的速度是有极大差异的，为了合理利用 CPU 的高性能，平衡这三者的速度差异，计算机体系结构、操作系统、编译程序都做出了贡献。

线程状态转换

新建(New)
创建后尚未启动。

就绪(Runnable)
可能正在运行，也可能正在等待 CPU 时间片。

包含了操作系统线程状态中的 Running 和 Ready。

阻塞(Blocking)
等待获取一个排它锁，如果其线程释放了锁就会结束此状态。

无限期等待(Waiting)
等待其它线程显式地唤醒，否则不会被分配 CPU 时间片。

限期等待(Timed Waiting)
无需等待其它线程显式地唤醒，在一定时间之后会被系统自动唤醒。

调用 Thread.sleep() 方法使线程进入限期等待状态时，常常用“使一个线程睡眠”进行描述。

调用 Object.wait() 方法使线程进入限期等待或者无限期等待时，常常用“挂起一个线程”进行描述。

睡眠和挂起是用来描述行为，而阻塞和等待用来描述状态。

阻塞和等待的区别在于，阻塞是被动的，它是在等待获取一个排它锁。而等待是主动的，通过调用 Thread.sleep() 和 Object.wait() 等方法进入。

死亡(Terminated)
可以是线程结束任务之后自己结束，或者产生了异常而结束。

线程使用方式

有三种使用线程的方法:

实现 Runnable 接口；
实现 Callable 接口；
继承 Thread 类。

实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。

继承 Thread 类


public class ThreadTest {
    
    public static void main(String[] args) {
//        创建Thread类的子类的对象
        MyThread t1 = new MyThread();
        //不能通过run方法开启线程，因为还会在主线程中运行，应该使用start方法开启线程
        //不能通过调用两次start方法来开启两个子线程
        t1.start();
 
        //可以通过再创建一个对象来实现
 
        for (int i=0;i<1000;i++){
            if (i%2!=0){
                System.out.println(i+"****");
            }
        }
    }
 
}
class MyThread extends Thread{
    @Override
    public void run() {
       for (int i=0;i<1000;i++){
           if (i%2==0){
               System.out.println(i);
           }
       }
    }
}

    
    public static void main(String[] args) {
 
        MyThread1 myThread1 = new MyThread1();
        myThread1.start();
        MyThread2 myThread2 = new MyThread2();
        myThread2.start();
 
        //通过匿名子类实现调用：特点只需要调用一次的子线程
        new Thread(){
            @Override
            public void run() {
                for (int i=0;i<1000;i++){
                    if (i%3==0){
                        System.out.println(Thread.currentThread().getName()+"***"+i);
                    }
                }
            }
        }.start();
    }
 
}
 
class MyThread1 extends Thread{
    @Override
    public void run() {
       for (int i=0;i<100;i++){
           if (i%2!=0){
               System.out.println(Thread.currentThread().getName()+"***"+i);
 
           }
       }
    }
}
class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+"***"+i);
            }
        }
    }
}

实现 Runnable 接口


package com.atguigu.juc.runnable;
 

 
public class TestThread {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MyThread myThread = new MyThread();
        //4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(myThread);
        //5，通过Thread类的对象调用start()
        t1.start();
    }
}
//1.创建一个实现Runnable接口的类
class MyThread implements Runnable{
//2.实现类去实现Runnable中的抽象方法: run( )
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if (i%2==0){
                System.out.println(i);
            }
        }
    }
}

实现 Callable 接口

线程常见方法


package com.atguigu.juc.tset01;
 

public class MyThreatTest {
    public static void main(String[] args) {
 
 
        TestMyThread t1 = new TestMyThread();
            t1.start();
        new Thread(){
            @Override
            public void run(){
                for (int i=0;i<100;i++){
                    if (i%2==0){
                        try {
                            sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "子线程" + i);
                        yield();
                    }
 
                }
            }
        }.start();
 
        for (int i=0;i<100;i++){
            if (i%3==0){
                System.out.println(Thread.currentThread().getName() + "main方法" + i);
            }
            if (i==20){
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
class TestMyThread extends Thread{
    @Override
    public void run(){
        for (int i=0;i<100;i++){
            if (i%5==0){
                System.out.println(Thread.currentThread().getName() + "2222222222222子线程" + i);
 
            }
 
        }
    }
}

synchronized锁机制

  • 一把锁只能同时被一个线程获取，没有获得锁的线程只能等待；
  • 每个实例都对应有自己的一把锁(this),不同实例之间互不影响；例外：锁对象是*.class以及synchronized修饰的是static方法的时候，所有对象公用同一把锁
  • synchronized修饰的方法，无论方法正常执行完毕还是抛出异常，都会释放锁

同步代码---Runnable接口方式



public class WindowToRunnable {
    public static void main(String[] args) {
        Window2 window2 = new Window2();
 
        Thread t1 = new Thread(window2);
        Thread t2 = new Thread(window2);
        Thread t3 = new Thread(window2);
 
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
 
        t1.start();
        t2.start();
        t3.start();
    }
}
class Window2 implements Runnable{
//这里不用加static,因为调用的对象只有一个
    private  int ticket=100;
    @Override
    public void run() {
 
            while (true) {
                synchronized (this.getClass()){
                if (ticket > 0) {
//                try {
//                    Thread.sleep(100);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                    System.out.println(Thread.currentThread().getName() + "买票,票号:" + ticket);
                    ticket--;
                }
            }
        }
    }
}

同步方法--Runnable接口方法


package com.atguigu.juc.bookPage;
 

 
public class WindowExtSynn {
    public static void main(String[] args) {
        Window4 w1 = new Window4();
        Window4 w2 = new Window4();
        Window4 w3 = new Window4();
 
        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");
 
        w1.start();
        w2.start();
        w3.start();
    }
}
 
class Window4 extends Thread{
    private static int ticket=100;
 
    @Override
    public void run() {
        while (true){
            show();
 
        }
    }
 
    private static synchronized void show() {
        if (ticket>0){
 
            System.out.println(Thread.currentThread().getName()+":买票：票号为"+ticket);
            ticket--;
        }
    }
}

同步方法---继承方法


package com.atguigu.juc.bookPage;
 

 
public class WindowExtSynn {
    public static void main(String[] args) {
        Window4 w1 = new Window4();
        Window4 w2 = new Window4();
        Window4 w3 = new Window4();
 
        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");
 
        w1.start();
        w2.start();
        w3.start();
    }
}
 
class Window4 extends Thread{
    private static int ticket=100;
 
    @Override
    public void run() {
        while (true){
            show();
 
        }
    }
 
    private static synchronized void show() {
        if (ticket>0){
 
            System.out.println(Thread.currentThread().getName()+":买票：票号为"+ticket);
            ticket--;
        }
    }
}

死锁

示例：两个线程都拿到第一层锁的key，然后都需要第二层锁的key，但key在对方手中，而方法没有执行完，都不可能释放key，互相僵持。


import static java.lang.Thread.sleep;
 
public class TestSyn {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();
        new Thread(){
            @Override
            public void run() {
                synchronized (s1) {
                    s1.append("a");
                    s2.append("1");
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2) {
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
 
            }
        }.start();
 
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2) {
                    s1.append("c");
                    s2.append("3");
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1) {
                        s1.append("d");
                        s2.append("4");
 
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }
}

Lock锁机制


import java.util.concurrent.locks.ReentrantLock;
 

public class LockTest {
    public static void main(String[] args) {
        Window6 window6 = new Window6();
        Thread t1 = new Thread(window6);
        Thread t2 = new Thread(window6);
        Thread t3 = new Thread(window6);
 
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
 
        t1.start();
        t2.start();
        t3.start();
 
    }
}
class Window6 implements Runnable{
    private int ticker=100;
 
    private ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){
            lock.lock();
            try {
                if (ticker>0){
                    System.out.println(Thread.currentThread().getName()+"买票：票号："+ticker);
 
                    ticker--;
                }else {
                    break;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

　　银行有一个账户。有两个储户分别向同一个账户存3000元，每次存1e00，存3次。每次存完打印账户余额。



public class AccountTest {
 
    public static void main(String[] args) {
        Account account = new Account(0);
        Customer c1 = new Customer(account);
        Customer c2 = new Customer(account);
        c1.setName("A");
        c2.setName("B");
        c1.start();
        c2.start();
    }
}
class Account{
    private double balance;
 
    public Account(double balance) {
        this.balance = balance;
    }
    //存钱
    public synchronized void deposit(double amt){
        //synchronized (this.getClass()) {
            if (amt>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                balance+=amt;
                System.out.println(Thread.currentThread().getName()+"存钱成功，余额为"+balance);
            }
       // }
    }
}
class Customer extends Thread{
    private Account acc;
    public Customer(Account acc){
        this.acc=acc;
    }
 
    @Override
    public void run() {
        for (int i=0;i<30;i++){
            acc.deposit(1000);
        }
    }
}

A存钱成功，余额为1000.0
B存钱成功，余额为2000.0
B存钱成功，余额为3000.0
B存钱成功，余额为4000.0
A存钱成功，余额为5000.0
A存钱成功，余额为6000.0

以上就是学习java多线程的详细内容，更多关于java多线程的资料请关注编程网其它相关文章！

您可能感兴趣的文档:

--结束END--

本文标题: 学习java多线程

本文链接: https://lsjlt.com/news/133535.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • 学习java多线程
    目录介绍为什么需要多线程线程状态转换线程使用方式继承 Thread 类实现 Runnable 接口实现 Callable 接口同步代码---Runnable接口方式同步方法--Run...
    99+
    2024-04-02
  • Java多线程学习笔记
    目录多任务、多线程程序、进程、线程学着看jdk文档线程的创建1.继承Thread类2.实现Runable接口理解并发的场景龟兔赛跑场景实现callable接口理解函数式接口理解线程的...
    99+
    2024-04-02
  • Java 多线程学习总结3
    在上一篇中，我们当然希望a++,b++执行完之后，show方法再来show.我们需要的是“原子”动作，一次性地把a++,b++不间断地执行。在java中是利用“互斥”的方法，互斥谁呢？互斥的是相同对象的加锁代码。如果我们把第一篇的SomeB...
    99+
    2023-01-31
    多线程 Java
  • Java多线程Thread基础学习
    目录1. 创建线程   1.1 通过构造函数：public Thread(Runnable target, String name){}  或：publ...
    99+
    2023-05-17
    Java多线程 Java 多线程Thread
  • Java学习随记之多线程编程
    Process和Thread 程序是指令和数据的有序集合， 本身没有运行的含义，是一个静态的概念。 进程是执行程序的一次执行过程，他是一个动态的概念，是系统资源分配的单位 一个进程中...
    99+
    2024-04-02
  • python多线程学习
    python多线程学习：python中的线程使用的两种方式：函数或者用类来包装线程对象。1、函数式：调用thread模块中start_new_thread()函数来产生新线程。#!/usr/bin/env python #coding:ut...
    99+
    2023-01-31
    多线程 python
  • Java多线程之锁的强化学习
    目录Java8锁SynchronizedReentrantLockAQSvolatile自旋锁 ，自旋锁的其他种类CAS 自旋锁CAS的实现原理首先强调一点：Java多线程的锁都是基...
    99+
    2023-02-26
    Java多线程 锁 Java多线程 Java 锁
  • Java多线程之锁学习(增强版)
    目录阻塞锁非阻塞锁锁的四种状态无锁状态偏向锁轻量级锁重量级锁可重入锁自旋锁读写锁互斥锁悲观锁乐观锁公平锁非公平锁显示锁和内置锁轮询锁和定时锁对象锁和类锁锁粗化锁消除信号量独享锁共享锁...
    99+
    2023-02-26
    Java多线程 锁 Java多线程 Java 锁
  • Python多线程学习 setDae
    （2）setDaemon方法： # -*- coding: utf-8 -*- import threading import time class myThread(threading.Thread):     def __init...
    99+
    2023-01-31
    多线程 Python setDae
  • Java零基础学习多线程的示例
    这篇文章给大家分享的是有关Java零基础学习多线程的示例的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。守护线程从线程分类上可以分为：用户线程（以上讲的都是用户线程），另一个是守护线程。守护线程是这样的，所有的用户...
    99+
    2023-06-06
  • 深入学习C#多线程
    目录一、基本概念1、进程2、线程二、多线程2.1System.Threading.Thread类2.2 线程的常用属性2.2.1线程的标识符2.2.2线程的优先级别2.2....
    99+
    2024-04-02
  • 多线程的学习上篇
    座右铭: 天行健，君子以自强不息;地势坤，君子以厚德载物. 引入进程这个概念的目的 引入进程这个概念,最主要的目的,是为了解决“并发编程"这样的问题. 这是因为CPU进入了多核心的时代 要想进一步提...
    99+
    2023-09-21
    学习 java 服务器
  • Python多线程入门学习
    Python 中使用线程有两种方式：函数或者用类来包装线程对象。 函数式： 调用 thread 模块中的start_new_thread()函数来产生新线程。 语法如下： thr...
    99+
    2024-04-02
  • 多线程学习初步(转)
    import java.io.*;//多线程编程public class MultiThread {public static void main(String args[]){System.out.println("我是主线程!");//...
    99+
    2023-06-03
  • Java多线程初学者需要学习哪些内容
    这篇文章主要介绍了Java多线程初学者需要学习哪些内容的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇Java多线程初学者需要学习哪些内容文章都会有所收获，下面我们一起来看看吧。线程简介介绍了什么是Java的线程...
    99+
    2023-06-17
  • Java学习星球，Java学习路线
    目录 一、Java学习路线二、学习计划三、为何会有Java学习星球？四、加入星球后，你可以得到什么？五、如何加入Java学习星球？六、打卡挑战 大家好，我是哪吒，一个靠着热情攀登至C...
    99+
    2023-08-31
    java 学习 开发语言
  • Python学习记录-多进程和多线程
    [TOC] 1. 进程和线程 进程 狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。广义定义：进程是一个具有一定独立功能的程序关于某...
    99+
    2023-01-31
    多线程 进程 Python
  • ReentrantLock从源码解析Java多线程同步学习
    目录前言管程管程模型MESA模型主要特点AQS共享变量资源访问方式主要方法队列node节点等待状态ReentrantLock源码分析实例化ReentrantLock加锁A线程加锁成功...
    99+
    2023-05-16
    Java多线程ReentrantLock Java ReentrantLock
  • 【Java系列】多线程案例学习——单例模式
    个人主页：兜里有颗棉花糖 欢迎 点赞👍 收藏✨ 留言✉ 加关注💓本文由 兜里有颗棉花糖 原创 收录于专栏【Java系列专栏】【JaveEE学习专栏】 本专栏旨在分享学习JavaEE的一点学习心得，欢迎大家...
    99+
    2023-12-23
    java 单例模式 java-ee
  • Android多线程学习实例详解
    本文实例分析了Android多线程。分享给大家供大家参考，具体如下： 在Android下面也有多线程的概念，在C/C++中，子线程可以是一个函数，一般都是一个带有循环的函数，来...
    99+
    2022-06-06
    学习 android多线程 线程 Android
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作