Learn compile principle

最新推荐文章于 2024-11-01 01:16:20 发布
原创 最新推荐文章于 2024-11-01 01:16:20 发布 · 2.3k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#compiler #reference #tools #gcc #c

本文精选了一系列关于算法和编程的学习资源，包括经典书籍如《计算机系统：程序员的视角》、《算法导论》等，涵盖了从编译原理到具体算法实现的多个方面，适合不同阶段的开发者学习使用。

 

 Plan is not enough, but Supervision. 

 I'm very appreciate to all friends' suggestion and help.

 Best wishes to this smart stars!

reference:

 1. ANSIC    ansi_c.pdf 1.34 MB

 2. Computer Systems A Programmer's Perspective

 3. Introduction To Algorithms

 4. Algorithms In C  Third Edition

 5. Compilers Principles, Techniques, and Tools

 6. Lemon 语法分析生成器（LALR（1）类型）源代码情景分析

 7. A Retargetable C Compiler: Design and Implementation supervising

 8. Optimizing Compilers for Modern Architectures

 9. Modern Compiler Design

 10. GUN gcc resource 

AI人工智能深度学习算法：在流体动力学中的应用
AI天才研究院
07-16 1774
solution总结（Summary）：深度学习在流体动力学中的应用已经显示出巨大的潜力，为传统的流体动力学研究和工程应用带来了新的视角和工具。通过本次分析，我们可以得出以下几点结论：多样化应用：深度学习在流体模拟、参数估计、流场重建、湍流建模和流体控制等多个方面都有成功的应用。让我们继续总结和展望深度学习在流体动力学中的应用。总结（Summary）：计算效率提升：相比传统的数值模拟方法，深度学习模型在预测阶段能够显著提高计算效率，使得实时流场预测和快速设计优化成为可能。
计算：第四部分 计算的极限 第 12 章 机器能思考吗 人工智能的圣杯
AI天才研究院
09-28 987
solution哲学角度：思考通常被认为是有意识的心理活动。认知科学角度：思考包括推理、问题解决、决策等认知过程。图灵测试：艾伦·图灵提出的判断机器是否能思考的方法。理解"思考"的多层含义对于我们探讨机器思考的可能性至关重要。stage自计算机诞生以来，机器能否思考一直是人工智能领域最为核心和引人入胜的问题。这一问题源于对计算本质的探讨，以及对人类智能的向往。在20世纪中叶，艾伦·图灵提出了著名的图灵测试，试图定义机器思考的界限，引发了一场关于人工智能本质的激烈辩论。
Compiler Principle
Jinyao的博客
09-17 361
Compiler Principle 1.Einleitung 1.1 Der Überblick über Compiler 1.1.1 Lexikalische Analyse Die lexikalische Analyse zerteilt den eingelesenen Quelltext in lexikalische Einh...
《xUnit Test Patterns》学习笔记4 - Principles of Test Automation
weixin_34043301的博客
01-23 213
自动化测试过程中，有一些基本的原则，就如同宣言(Manifesto)。由于大部分的原则在前面其实都提到的，因此，有的不做太多说明了。 原则：Write the Tests First 原则：Design for Testability 原则：Use the Front Door First 意思是说，从最外层暴露的publish方法开始测试。 原则：Communicate Intent ...
Learn Decorator Design Pattern in Easy Steps
a19576的专栏
07-03 660
http://www.codeproject.com/Articles/99469/Learn-Decorator-Design-Pattern-in-Easy-Steps Introduction Kartoon Kompany approaches you for re-designing their application on the famous Kelvin and Hoppes
装饰设计模式 Learn Decorator Design Pattern in Easy Steps
smilestone322的专栏
05-05 1148
Learn Decorator Design Pattern in Easy Steps 转自：http://www.codeproject.com/Articles/99469/Learn-Decorator-Design-Pattern-in-Easy-Steps
Visual C++ vs Visual C# , which is the best to learn?
学习笔记
08-09 404
Stackoverflow： Visual C++ and Visual C# are not languages nor GUI frameworks; they are Integrated Development Environments - IDEs. This means they are text editors tailored to the task of development...
认知增强与人机协作：未来工作模式的探索
AI天才研究院
11-01 950
在21世纪的第三个十年，我们正站在一个前所未有的技术变革浪潮之巅。人工智能、大数据、物联网等新兴技术的迅猛发展，正在深刻地改变着我们的生活方式和工作模式。在这个智能时代，认知增强与人机协作作为两个关键概念，正在重新定义人类与机器的关系，并为未来的工作模式带来革命性的变革。传统的工作模式正面临着前所未有的挑战。随着信息爆炸和知识更新速度的加快，人类的认知能力似乎已经难以跟上时代的步伐。与此同时，人工智能技术的飞速发展又让许多人担心自己的工作岗位会被机器取代。
Java 之父 James Gosling 最新访谈：JIT 很好，但不适合所有语言
热门推荐
AI天才研究院
08-27 1万+
计算机编程确实是一门艺术。James Gosling，“Java 之父”, 完成了 Java 的原始设计，并实现了 Java 最初版本的编译器和虚拟机。90年代初，James Goslin...
Chapter 3: Introduction to Objects and Classes The Object-Oriented Paradigm Course: CS101: Java Language Programming Instructor: [Instructor Name] Date: September 22, 2025 Practical Session Objective Lab Goal: Refactor to an Object-Oriented Design Our goal is to stop using loose, primitive variables to represent our contact and instead create a proper Contact object. This is a foundational step in building professional software. Prerequisites: Java JDK 11 or higher installed. An IDE like IntelliJ IDEA or VS Code ready. Your MyContactManager project from the last lab. Final Result Preview: The console output will look exactly the same as before, but the underlying code structure will be vastly superior, organized, and ready for future expansion. Step 1: Create the Contact Class Blueprint First, we need to create the blueprint for what a "Contact" is in our application. 1. Goal: Create a new Contact.java file and define the state of a contact. 2. Instructions: 1. In your IDE's project explorer, right-click on your source folder and create a new Java Class. 2. Name the file Contact . This will generate Contact.java . 3. Inside the Contact class, declare the instance variables that every contact will have. These are the same variables that are currently cluttering up your main method. 3. Code Block (for Contact.java ): --- Contact Details --- Name: John Doe Age: 42 Phone: 555-1234 1 2 3 44. Expected Result: You now have two files in your project: MyContactManager.java and Contact.java . The code should compile without errors. Step 2: Instantiate a Contact Object Now that we have the blueprint, let's go back to our main application and create an actual contact from it. 1. Goal: In MyContactManager.java , replace the old primitive variables with a single Contact object. 2. Instructions: 1. Open MyContactManager.java . 2. Delete all the old variable declarations for the contact ( String firstName = "Jane"; , int age = 32; , etc.). 3. In their place, declare and instantiate a new Contact object. 3. Code Block (in main method of MyContactManager.java ): 4. Expected Result: Your main method is now much cleaner. Your code will no longer compile because the parts that used the old variables are now broken. This is good! We'll fix it next. Step 3: Set the Object's State Our contact1 object exists, but its instance variables are all empty ( null or 0 ). Let's fill them with data using dot notation. 1. Goal: Assign values to the instance variables of our new contact1 object. public class Contact { // Instance variables to hold the state of a single contact String firstName; String lastName; int age; String phoneNumber; boolean isFriend; } 1 2 3 4 5 6 7 8 public static void main(String[] args) { // Delete the old variables: // String firstName = "Jane"; (DELETE) // String lastName = "Doe"; (DELETE) // int age = 32; (DELETE) // ...and so on. // Create an object from our blueprint Contact contact1 = new Contact(); // Now we have a single variable, 'contact1', that holds all // the information about our contact. } 1 2 3 4 5 6 7 8 9 10 11 12 132. Instructions: 1. After the line Contact contact1 = new Contact(); , use the dot operator to access each instance variable and assign it a value. 3. Code Block (in main method of MyContactManager.java ): 4. Expected Result: The contact1 object in memory now holds all the data for John Doe. The code still won't compile because the System.out.println statements are broken. Step 4: Get the Object's State Finally, let's fix our print statements to read the data back from the object, again using dot notation. 1. Goal: Update the System.out.println statements to use the object's fields. 2. Instructions: 1. Find your old println statements that are showing compile errors. 2. Prefix each old variable name with contact1. to tell Java to get the value from the object. 3. Code Block (in main method of MyContactManager.java ): 4. Expected Result: All compile errors should now be gone! Your application is fully refactored. // ... after creating the contact object Contact contact1 = new Contact(); // Use dot notation to set the object's state contact1.firstName = "John"; contact1.lastName = "Doe"; contact1.age = 42; contact1.phoneNumber = "555-1234"; contact1.isFriend = false; 1 2 3 4 5 6 7 8 9 // ... after setting the object's state System.out.println("\n--- Contact Details ---"); // OLD: System.out.println("Name: " + firstName + " " + lastName); // NEW: System.out.println("Name: " + contact1.firstName + " " + contact1.lastName); // OLD: System.out.println("Age: " + age); // NEW: System.out.println("Age: " + contact1.age); // OLD: System.out.println("Phone: " + phoneNumber); // NEW: System.out.println("Phone: " + contact1.phoneNumber); 1 2 3 4 5 6 7 8 9 10 11 12 13 14Final Code and Verification Let's look at the final, refactored MyContactManager.java and verify that it works. 1. Goal: Run the application and confirm the output is correct. 2. Code Block (Complete MyContactManager.java ): 3. Expected Output: Success! The output is the same, but our code structure is infinitely better. Optional Challenge Task For Those Who Finish Early... 🚀 If you've completed the refactoring, this challenge will solidify your understanding of objects. Challenge: Create a Second, Independent Object 1. In your main method, create a second Contact object called contact2 . 2. Set the state for contact2 with completely different data (e.g., "Jane Smith", age 35, etc.). 3. Add println statements to display the details for contact2 after displaying the details for contact1 . public class MyContactManager { public static void main(String[] args) { // 1. Create an object (an instance) from the Contact class blueprint Contact contact1 = new Contact(); // 2. Set the state of the object using dot notation contact1.firstName = "John"; contact1.lastName = "Doe"; contact1.age = 42; contact1.phoneNumber = "555-1234"; contact1.isFriend = false; // 3. Get the state of the object using dot notation System.out.println("--- Contact Details ---"); System.out.println("Name: " + contact1.firstName + " " + contact1.lastName); System.out.println("Age: " + contact1.age); System.out.println("Phone: " + contact1.phoneNumber); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 --- Contact Details --- Name: John Doe Age: 42 Phone: 555-1234 1 2 3 4This will prove that contact1 and contact2 are two separate objects in memory, each with its own independent state, even though they were built from the same class blueprint. Q&A and Wrap-up Questions? Today's Most Important Lesson Organizing code into classes that model real-world concepts is the single most powerful strategy for managing complexity in software. We took a chaotic collection of variables and transformed it into a clean, intuitive structure. A Contact is now a "thing" in our program, just as it is in the real world. This is the foundation upon which all large-scale, professional applications are built. What's Next? Up Next: Protecting Our Objects Right now, our code has a major flaw. Anyone using our Contact class can do this: contact1.age = -99; contact1.phoneNumber = "this is not a phone number"; This is dangerous and leads to bugs! An object should be in control of its own data. Next Lecture: Chapter 4: Deeper Dive into Classes - Encapsulation We'll learn about encapsulation, a core OOP principle for data hiding and protection. We'll introduce private variables and public getter/setter methods to create robust, bug-resistant objects. 以上问题的答案是什么
09-21
### 从使用原始变量到创建 Contact 对象的代码重构步骤 #### 1. 分析原始代码 假设原始代码使用多个独立的变量来存储联系人信息，例如： ```java // 原始代码使用独立变量存储联系人信息 String contactName = ...
Your feedback is requested on changes under consideration for SLF4J version 2.1.0. SLF4J warning or error messages and their meanings No SLF4J providers were found. This message is a warning and not an error. It is reported when no SLF4J providers could be found on the class path. SLF4J requires a logging provider because it is a logging API and not an logging implementation. Placing one (and only one) of the many available providers such as slf4j-nop.jar slf4j-simple.jar, slf4j-reload4j.jar, slf4j-jdk14.jar or logback-classic.jar on the class path will solve the problem. In the absence of a provider, SLF4J will default to a no-operation (NOP) logger provider. Please note that slf4j-api version 2.0.x and later use the ServiceLoader mechanism. Earlier versions relied on the static binder mechanism which is no longer honored by slf4j-api. Please read the FAQ entry What has changed in SLF4J version 2.0.0? for further important details. If you are responsible for packaging an application and do not care about logging, then placing slf4j-nop.jar on the class path of your application will get rid of this warning message. Note that embedded components such as libraries or frameworks should not declare a dependency on any SLF4J providers but only depend on slf4j-api. When a library declares a compile-time dependency on a SLF4J provider, it imposes that provider on the end-user, thus negating SLF4J's purpose. Class path contains SLF4J bindings targeting slf4j-api versions 1.7.x or earlier Planning for the advent of Jigsaw (Java 9), slf4j-api version 2.0.x and later use the ServiceLoader mechanism. Earlier versions of SLF4J relied on the static binder mechanism which is no longer honored by slf4j-api version 2.0.x. In case SLF4J 2.x finds no providers targeting SLF4J 2.x but finds instead bindings targeting SLF4J 1.7 or earlier, it will list the bindings it finds but otherwise will ignore them. This can be solved by placing an SLF4J provider on your classpath, such providers include logback version 1.3.x and later, as well as one of slf4j-reload4j, slf4j-jdk14, slf4j-simple version 2.0.0 or later. See also the FAQ entry What has changed in SLF4J version 2.0.0? for further important details. IllegalStateException: org.slf4j.LoggerFactory in failed state. Original exception was thrown EARLIER. This IllegalStateException is thrown post-initialization and informs the user that initialization of LoggerFactory has failed. Note It is important to realize that the exception causing the failure was thrown at an earlier stage. This earlier exception should provide more valuable information about the root cause of the problem. The method o.a.commons.logging.impl.SLF4FLogFactory#release was invoked. Given the structure of the commons-logging API, in particular as implemented by SLF4J, the o.a.commons.logging.impl.SLF4FLogFactory#release() method should never be called. However, depending on the deployment of commons-logging.jar files in your servlet container, release() method may be unexpectedly invoked by a copy of org.apache.commons.logging.LogFactory class shipping with commons-logging.jar. This is a relatively common occurrence with recent versions of Tomcat, especially if you place jcl-over-slf4j.jar in WEB-INF/lib directory of your web-application instead of $TOMCAT_HOME/common/lib, where $TOMCAT_HOME stands for the directory where Tomcat is installed. In order to fully benefit from the stability offered by jcl-over-slf4j.jar, we recommend that you place jcl-over-slf4j.jar in $TOMCAT_HOME/common/lib without placing a copy in your web-applications. Please also see bug #22. Operation [suchAndSuch] is not supported in jcl-over-slf4j. An UnsupportedOperationException is thrown whenever one of the protected methods introduced in JCL 1.1 are invoked. These methods are invoked by LogFactory implementations shipping with commons-logging.jar. However, the LogFactory implemented by jcl-over-slf4j.jar, namely SLF4FLogFactory, does not call any of these methods. If you observe this problem, then it is highly probable that you have a copy of commons-logging.jar in your class path overriding the classes shipping with jcl-over-slf4j.jar. Note that this issue is very similar in nature to the warning issued when the "o.a.commons.logging.impl.SLF4FLogFactory.release()" method is invoked, discussed in the previous item. Detected logger name mismatch Logger name mismatch warnings are printed only if the slf4j.detectLoggerNameMismatch system property is set to true. By default, this property is not set and no warnings will be printed even in case of a logger name mismatch. since 1.7.9 The warning will be printed in case the name of the logger specified via a class passed as an argument to the LoggerFactory.getLogger(Class) method differs from the name of the caller as computed internally by SLF4J. For example, the following code snippet package com.acme; import com.foo.Kangaroo; class Fruit { Logger logger = LoggerFactory.getLogger(Kangaroo.class); } will result in the warning SLF4J: Detected logger name mismatch. Given name: "com.foo.Kangaroo"; computed name: "com.acme.Fruit". but only if slf4j.detectLoggerNameMismatch system property is set to true. No warning will be issued for the special case where the class in which the logger is defined is a super-type of the class parameter passed as argument. For example, class A { Logger logger = LoggerFactory.getLogger(getClass()); } class B extends A { // no mismatch warning will be issued when B is instantiated // given that class A is a super-type of class B } If you come across a mismatch warning which cannot be explained, then you might have spotted a white elephant, that is a very rare occurrence where SLF4J cannot correctly compute the name of the class where a logger is defined. We are very interested to learn about such cases. If and when you spot an inexplicable mismatch, please do file a bug report with us. Failed to load class org.slf4j.impl.StaticLoggerBinder This warning message is reported by slf4j-api version 1.7.x and earlier when the org.slf4j.impl.StaticLoggerBinder class could not be loaded into memory. This happens when no appropriate SLF4J binding could be found on the class path. Placing one (and only one) of slf4j-nop.jar slf4j-simple.jar, slf4j-log4j12.jar, slf4j-jdk14.jar or logback-classic.jar on the class path should solve the problem. If you are seeing this message, then you are NOT using slf4j-api version 2.0 or later but slf4j-api version 1.7.x or earlier. Slf4j-api versions 2.0.x and later use the ServiceLoader mechanism. Backends such as logback 1.3 and later which target slf4j-api 2.x, do not ship with org.slf4j.impl.StaticLoggerBinder. If you place a logging backend which targets slf4j-api 2.0.x, you need slf4j-api-2.x.jar on the classpath. See also relevant faq entry. since 1.6.0 As of SLF4J version 1.6, in the absence of a binding, SLF4J will default to a no-operation (NOP) logger implementation. If you are responsible for packaging an application and do not care about logging, then placing slf4j-nop.jar on the class path of your application will get rid of this warning message. Note that embedded components such as libraries or frameworks should not declare a dependency on any SLF4J binding (or provider) but only depend on slf4j-api. When a library declares a compile-time dependency on a SLF4J binding (or provider), it imposes that binding (or provider) on the end-user, thus negating SLF4J's purpose. Multiple bindings were found on the class path SLF4J API is designed to bind with one and only one underlying logging framework at a time. If more than one binding is present on the class path, SLF4J will emit a warning, listing the location of those bindings. When multiple bindings are available on the class path, select one and only one binding you wish to use, and remove the other bindings. For example, if you have both slf4j-simple-2.0.17.jar and slf4j-nop-2.0.17.jar on the class path and you wish to use the nop (no-operation) binding, then remove slf4j-simple-2.0.17.jar from the class path. The list of locations that SLF4J provides in this warning usually provides sufficient information to identify the dependency transitively pulling in an unwanted SLF4J binding into your project. In your project's pom.xml file, exclude this SLF4J binding when declaring the unscrupulous dependency. For example, cassandra-all version 0.8.1 declares both log4j and slf4j-log4j12 as compile-time dependencies. Thus, when you include cassandra-all as a dependency in your project, the cassandra-all declaration will cause both slf4j-log4j12.jar and log4j.jar to be pulled in as dependencies. In case you do not wish to use log4j as the SLF4J backend, you can instruct Maven to exclude these two artifacts as shown next: <dependencies> <dependency> <groupId> org.apache.cassandra</groupId> <artifactId>cassandra-all</artifactId> <version>0.8.1</version> <exclusions> <exclusion> <groupId>org.slf4j</groupId> <artifactId>slf4j-log4j12</artifactId> </exclusion> <exclusion> <groupId>log4j</groupId> <artifactId>log4j</artifactId> </exclusion> </exclusions> </dependency> </dependencies> Note The warning emitted by SLF4J is just that, a warning. Even when multiple bindings are present, SLF4J will pick one logging framework/implementation and bind with it. The way SLF4J picks a binding is determined by the JVM and for all practical purposes should be considered random. As of version 1.6.6, SLF4J will name the framework/implementation class it is actually bound to. Embedded components such as libraries or frameworks should not declare a dependency on any SLF4J binding but only depend on slf4j-api. When a library declares a compile-time dependency on a SLF4J binding, it imposes that binding on the end-user, thus negating SLF4J's purpose. When you come across an embedded component declaring a compile-time dependency on any SLF4J binding, please take the time to contact the authors of said component/library and kindly ask them to mend their ways. slf4j-api version does not match that of the binding An SLF4J binding designates an artifact such as slf4j-jdk14.jar or slf4j-log4j12.jar used to bind slf4j to an underlying logging framework, say, java.util.logging and respectively log4j. Mixing different versions of slf4j-api.jar and SLF4J binding (a.k.a. provider since 2.0.0) can cause problems. For example, if you are using slf4j-api-2.0.17.jar, then you should also use slf4j-simple-2.0.17.jar, using slf4j-simple-1.5.5.jar will not work. Note From the client's perspective all versions of slf4j-api are compatible. Client code compiled with slf4j-api-N.jar will run perfectly fine with slf4j-api-M.jar for any N and M. You only need to ensure that the version of your binding matches that of the slf4j-api.jar. You do not have to worry about the version of slf4j-api.jar used by a given dependency in your project. You can always use any version of slf4j-api.jar, and as long as the version of slf4j-api.jar and its binding match, you should be fine. At initialization time, if SLF4J suspects that there may be an api vs. binding version mismatch problem, it will emit a warning about the suspected mismatch. Logging factory implementation cannot be null This error is reported when the LoggerFactory class could not find an appropriate binding. Placing one (and only one) of slf4j-nop.jar, slf4j-simple.jar, slf4j-log4j12.jar, slf4j-jdk14.jar or logback-classic.jar on the class path should prove to be an effective remedy. Detected both log4j-over-slf4j.jar AND slf4j-reload4j on the class path, preempting StackOverflowError. The purpose of slf4j-reload4j module is to delegate or redirect calls made to an SLF4J logger to log4j/reload4j. The purpose of the log4j-over-slf4j module is to redirect calls made to a log4j logger to SLF4J. If SLF4J is bound withslf4j-reload4j.jar and log4j-over-slf4j.jar is also present on the class path, a StackOverflowError will inevitably occur immediately after the first invocation of an SLF4J or a log4j logger. Here is how the exception might look like: Exception in thread "main" java.lang.StackOverflowError at java.util.Hashtable.containsKey(Hashtable.java:306) at org.apache.log4j.Log4jLoggerFactory.getLogger(Log4jLoggerFactory.java:36) at org.apache.log4j.LogManager.getLogger(LogManager.java:39) at org.slf4j.impl.Log4jLoggerFactory.getLogger(Log4jLoggerFactory.java:73) at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:249) at org.apache.log4j.Category.<init>(Category.java:53) at org.apache.log4j.Logger..<init>(Logger.java:35) at org.apache.log4j.Log4jLoggerFactory.getLogger(Log4jLoggerFactory.java:39) at org.apache.log4j.LogManager.getLogger(LogManager.java:39) at org.slf4j.impl.Log4jLoggerFactory.getLogger(Log4jLoggerFactory.java:73) at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:249) at org.apache.log4j.Category..<init>(Category.java:53) at org.apache.log4j.Logger..<init>(Logger.java:35) at org.apache.log4j.Log4jLoggerFactory.getLogger(Log4jLoggerFactory.java:39) at org.apache.log4j.LogManager.getLogger(LogManager.java:39) subsequent lines omitted... Since 1.5.11 SLF4J software preempts the inevitable stack overflow error by throwing an exception with details about the actual cause of the problem. This is deemed to be better than leaving the user wondering about the reasons of the StackOverflowError. Note that since reload4j provides the log4j 1.x API, reload4j.jar and log4j-over-slf4j.jar cannot be present simultaneously on your classpath. For more background on this topic see Bridging legacy APIs. Detected both jcl-over-slf4j.jar AND slf4j-jcl.jar on the class path, preempting StackOverflowError. The purpose of slf4j-jcl module is to delegate or redirect calls made to an SLF4J logger to jakarta commons logging (JCL). The purpose of the jcl-over-slf4j module is to redirect calls made to a JCL logger to SLF4J. If SLF4J is bound with slf4j-jcl.jar and jcl-over-slf4j.jar is also present on the class path, then a StackOverflowError will inevitably occur immediately after the first invocation of an SLF4J or a JCL logger. Here is how the exception might look like: Exception in thread "main" java.lang.StackOverflowError at java.lang.String.hashCode(String.java:1482) at java.util.HashMap.get(HashMap.java:300) at org.slf4j.impl.JCLLoggerFactory.getLogger(JCLLoggerFactory.java:67) at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:249) at org.apache.commons.logging.impl.SLF4JLogFactory.getInstance(SLF4JLogFactory.java:155) at org.apache.commons.logging.LogFactory.getLog(LogFactory.java:289) at org.slf4j.impl.JCLLoggerFactory.getLogger(JCLLoggerFactory.java:69) at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:249) at org.apache.commons.logging.impl.SLF4JLogFactory.getInstance(SLF4JLogFactory.java:155) subsequent lines omitted... Since 1.5.11 SLF4J software preempts the inevitable stack overflow error by throwing an exception with details about the actual cause of the problem. This is deemed to be better than leaving the user wondering about the reasons of the StackOverflowError. For more background on this topic see Bridging legacy APIs. Exception in thread "main" java.lang.NoSuchFieldError: tlm Exception in thread "main" java.lang.NoSuchFieldError: tlm at org.apache.log4j.MDCFriend.fixForJava9(MDCFriend.java:11) at org.slf4j.impl.Log4jMDCAdapter.(Log4jMDCAdapter.java:38) at Main.main(Main.java:5) The NoSuchFieldError is thrown when slf4j-log4j12 attempts to access the 'tlm' package private field in org.apache.log4j.MDC which was specified as being of type java.lang.Object in log4j 1.2.x but was changed to java.lang.ThreadLocal in reload4j. Moreover, such access to package private fields from different modules is not authorized by default in modularized applications in Java 9 and later. To keep a long story short, the NoSuchFieldError can be avoided by using slf4j-reload4j.jar with reload4j.jar. Stated differently, org.slf4j.MDC cannot be used with the slf4j-log4j12.jar and reload4j.jar combination. Update: The issue described above was fixed in reload4j 1.2.21. Although it is still recommended that you use slf4j-reload4j as the preferred adapter for the slf4j/reload4j combination, with reload4j version 1.2.21 and later you can freely mix any version of slf4j-log4j12, if you need to. Failed to load class "org.slf4j.impl.StaticMDCBinder" This error indicates that appropriate SLF4J binding could not be found on the class path. Placing one (and only one) of slf4j-nop.jar, slf4j-simple.jar, slf4j-log4j12.jar, slf4j-jdk14.jar or logback-classic.jar on the class path should solve the problem. MDCAdapter cannot be null This error is reported when org.slf4j.MDC class has not been initialized correctly. Same cause and remedy as the previously listed item. A number (N) of logging calls during the initialization phase have been intercepted and are now being replayed. These are subject to the filtering rules of the underlying logging system. since 1.7.15 Logging calls made during the initialization phase are recorded and replayed post-initialization. Note that the replayed logging calls are subject to filtering by the underlying logging system. In principle, replaying only occurs for applications which are already multithreaded at the time the first logging call occurs. See also substitute loggers. Substitute loggers were created during the default configuration phase of the underlying logging system Highly configurable logging systems such as logback and log4j may create components which invoke loggers during their own initialization. See issue LOGBACK-127 for a typical occurrence. However, since the binding process with SLF4J has not yet completed (because the underlying logging system was not yet completely loaded into memory), it is not possible to honor such logger creation requests. To avoid this chicken-and-egg problem, SLF4J creates substitute loggers during this phase (initialization). Calls made to the substitute loggers during this phase are simply dropped. After the initialization completes, the substitute logger will delegate logging calls to the appropriate logger implementation and otherwise will function as any other logger returned by LoggerFactory. If any substitute logger had to be created, SLF4J will emit a listing of such loggers. This list is intended to let you know that any logging calls made to these loggers during initialization have been dropped. See also intercepted and replayed logging calls. SLF4J versions 1.4.0 and later requires log4j 1.2.12 or later The trace level was added to log4j in version 1.2.12 released on August 29, 2005. The trace level was added to the SLF4J API in version 1.4.0 on May 16th, 2007. Thus, starting with SLF4J 1.4.0, the log4j binding for SLF4J requires log4j version 1.2.12 or above. However, as reported in issue 59, in some environments it may be difficult to upgrade the log4j version. To accommodate such circumstances, SLF4J's Log4jLoggerAdapter will map the TRACE level as DEBUG. java.lang.NoClassDefFoundError: org/slf4j/event/LoggingEvent Logback-classic version 1.1.4 and later require slf4j-api version 1.7.15 or later. With an earlier slf4j-api.jar in the classpath, attempting introspection of a Logger instance returned by logback version 1.1.4 or later will result in a NoClassDefFoundError similar to that shown below. Exception in thread "main" java.lang.NoClassDefFoundError: org/slf4j/event/LoggingEvent at java.lang.Class.getDeclaredMethods0(Native Method) at java.lang.Class.privateGetDeclaredMethods(Class.java:2451) at java.lang.Class.privateGetPublicMethods(Class.java:2571) at java.lang.Class.getMethods(Class.java:1429) at java.beans.Introspector.getPublicDeclaredMethods(Introspector.java:1261) at java.beans.Introspector.getTargetMethodInfo(Introspector.java:1122) at java.beans.Introspector.getBeanInfo(Introspector.java:414) at java.beans.Introspector.getBeanInfo(Introspector.java:161) Placing slf4j-api.jar version 1.7.15 or later in the classpath should solve the issue. Note that this problem only occurs with logback version 1.1.4 and later, other bindings such as slf4j-log4j, slf4j-jdk14 and slf4j-simple are unaffected.
最新发布
09-24
### 常见 SLF4J 警告和错误消息及解决办法 #### 1. `No SLF4J providers were found` - **含义**：在类路径中找不到 SLF4J 提供程序。SLF4J 是日志记录 API，需要日志记录提供程序来实现具体的日志功能[^2]。...
K8s 很难么？带你从头到尾捋一遍，不信你学不会
民工哥的博客
02-23 1万+
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）
北豼不太皮的博客
02-21 4181
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）一、学习目标二、了解单片机STM32F401RET6三、C语言基础 一、学习目标 二、了解单片机STM32F401RET6 4、STM32F401RE特征 三、C语言基础 1.数据类型 常用2的次方： 2^7 = 128 2^8 = 256 2^15 = 32768 2^16= 65536 51单片机常见的数据类型： char: 占内存1字节 取值范围：-128~127 -2^7 ~ 2
Android开发（1） | Fragment 的应用——新闻应用
Jormungand_V的博客
02-21 7533
文章目录 news_item.xml： <TextView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/news_title" android:layout_width="match_parent" android:layout_height="wrap_content" android:lines="1" android:ellipsize="
系统学习 TypeScript（四）——变量声明的初步学习
编程三昧
02-25 2057
认识了 TypeScript 中的基础类型，接下来当然是变量声明的相关学习了，我在这里记录一下我学习过程中的一些总结。
Design Compile综合软件的入门指南
Design Compile，作为Synopsys公司推出的一款综合软件，广泛应用于电子设计自动化领域。它的核心功能是将寄存器传输级（RTL）的代码转化为门级网表，这一步骤是集成电路设计的关键环节。为了帮助设计人员更好地理解...
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值