unkn0wn's questions

有一个JS代码可以在用户滚动页面时执行加载内容的功能，它可以正常工作。情况是，当为预期无限滚动的块明确设置特定高度时（当然，这取决于保存的数据量），一切正常。

问题在于设置一个明确的块高度，height: 100vh或者height: 300px说得委婉一点，从自适应模板的角度来看，这是一个不正确的解决方案。通过将属性块设置为height: 100%函数，无限滚动将不再起作用。

所以问题是如何在flexbox不使用明确的块高度属性（如 height: 100vhor ）的情况下让无限滚动功能工作height: 300px？

页面布局：

html,
body {
  height: 100%;
}

#workspace {
  display: flex;
  min-height: 100%;
}

.content {
  display: flex;
  flex: 1 1 auto;
}

#header,
#footer {
  display: flex;
  height: 56px;
}

#stretch-box {
  display: flex;
  flex: 1 1 auto;
}

#left-box {
  min-width: 300px;
}

#right-box {
  display: flex;
  align-items: flex-start;
  flex: 1 1 auto;
  flex-flow: row wrap;
  //height: 100vh;
  overflow: auto;
  justify-content: space-evenly;
}

<div id="workspace">
  <!-- HEADER -->
  <header id="header">
    // data
  </header>

  <!-- MAIN CONTENT -->
  <section class="content">
    <div id="stretch-box">

      <!-- LEFT BOX -->
      <div id="left-box">
        // data
      </div>

      <!-- RIGHT BOX -->
      <div id="right-box">
      </div>
    </div>
  </section>

  <!-- FOOTER -->
  <footer id="footer">
    // data
  </footer>
</div>

不使用属性 height: 100vh;：#right-box

将属性height: 100vh;用于#right-box：

我尝试向每个父块添加一个相对#right-box属性height: 100%;，然后另外overflow: auto;- 无济于事。

有表：

1. gift_certificate（礼券）
2. tag（标签）
3. gift_certificate_to_tag_relation（对于礼券和标签之间的多对多关系，包含ID）

如何使用 Criteria Query 查询具有特定标签集的礼券。标签被传递给Set<String> tagNames.

Java 实体：

1. GiftCertificate.class：

private Long id;
@Column(nullable = false, unique = true)
private String name;

@Column(nullable = false)
private String description;

@Column(nullable = false)
private BigDecimal price;

@Column(nullable = false)
private Integer duration;

@Column(nullable = false)
private LocalDateTime createDate;

@Column(nullable = false)
private LocalDateTime lastUpdateDate;

2. Tag.class：

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@Column(nullable = false, unique = true)
private String name;

3. GiftCertificateToTagRelation.class：

@Id
@ManyToOne
@JoinColumn(name = DatabaseColumnName.GIFT_CERTIFICATE_ID)
private GiftCertificate giftCertificate;

@Id
@ManyToOne
@JoinColumn(name = DatabaseColumnName.TAG_ID)
private Tag tag;

我正在尝试什么：

Set<String> tagNames = ...

CriteriaBuilder builder = em.getCriteriaBuilder();
CriteriaQuery<GiftCertificate> criteriaQuery = builder.createQuery(GiftCertificate.class);
Root<GiftCertificate> root = criteriaQuery.from(GiftCertificate.class);
Root<GiftCertificateToTagRelation> relationRoot = criteriaQuery.from(GiftCertificateToTagRelation.class);
Join<GiftCertificateToTagRelation, Tag> tagJoin = relationRoot.join("tag");
Predicate condition = tagJoin.get("name").in(tagNames);
criteriaQuery.where(condition)
    .groupBy(root)
    .having(builder.count(root).in(tagNames.size()));

作为这个查询的结果Hibernate，它会生成一个 SQL 查询（在传递两个标签名称的情况下）：

select *
from gift_certificate gc
         cross join gift_certificate_to_tag_relation relation
         inner join tag tag3_ on relation.tag_id = tag3_.id
where tag3_.name in ('tag1', 'tag2')
group by gc.id
having count(gc.id) in (2)
order by gc.id;

但是这个 SQL 代码返回一个空结果。我发现如果你在 line 中cross join添加一个条件 on gc.id = relation.gift_certificate_id，结果就是想要的结果：

select *
from gift_certificate gc
         cross join gift_certificate_to_tag_relation relation on gc.id = relation.gift_certificate_id
         inner join tag tag3_ on relation.tag_id = tag3_.id
where tag3_.name in ('tag1', 'tag2')
group by gc.id
having count(gc.id) in (2)
order by gc.id;

我知道条件ON是在Join<?, ?>. 但是 c 如何使用 Criteria Query 来设置这个词ON（on gc.id = relation.gift_certificate_id）？

为了映射 GET 请求，我使用注释@GetMapping：

@GetMapping(params = {ParameterName.SORT_BY})
    public List<GiftCertificate> findAllSorted(@RequestParam(value = ParameterName.SORT_BY) Set<ColumnName> columnNames) {

        return service.findAllSorted(columnNames);
    }

ParameterName.SORT_BY是一个常规枚举。

根据要求：

http://localhost:8080/gift-certificates?sort_by=name

我进入这个方法，一切都很好。但是，为什么在指定映射中不存在的参数时，应请求：

http://localhost:8080/gift-certificates?sort_ABRAKADABRA_by=name

我进入这个方法：

@GetMapping
    public List<GiftCertificate> findAll() {
        return service.findAll();
    }

为什么以及如何检查 GET 请求参数？

PS这是小号不敢出现在评论里乱戳关题原因的关卡，因为没有合适的。这就是屁应该被轰炸的方式:)

控制器中有一个方法可以处理 GET 请求。此方法用 注释@GetMapping(params = {ParameterName.SORT_BY, ParameterName.SORT_TYPE})。参数中的这个方法在注释的帮助下将@RequestParam来自 GET 请求的参数绑定到 String 类型的 Java 变量。它看起来像这样：

@GetMapping(params = {ParameterName.SORT_BY, ParameterName.SORT_TYPE})
    public List<GiftCertificate> findAllAndSort(@RequestParam(value = ParameterName.SORT_BY) String sortBy,
                                                @RequestParam(value = ParameterName.SORT_TYPE, required = false) String sortType) {
        log.info("Sorting: {}, {}", sortBy, sortType);

        return service.findAllAndSort(sortType, sortBy);
    }

参数sortType有一个required = false，这意味着给定的参数不必是: @RequestParam(value = ParameterName.SORT_TYPE, required = false) String sortType)。

消息来源说：

映射请求的参数，缩小主映射。适用于任何环境的相同格式：一系列“myParam=myValue”样式表达式，仅在发现每个此类参数具有给定值时才映射请求。表达式可以通过使用“！=”运算符来否定，如“myParam！= myValue”。还支持“myParam”样式表达式，此类参数必须存在于请求中（允许具有任何值）。最后，“！myParam”样式表达式表明指定的参数不应该出现在请求中。在类型级别和方法级别都支持！在类型级别使用时，所有方法级别映射都继承此参数限制。

这意味着@GetMapping(params = {...})在请求中指定的所有参数都必须存在。那为什么要在里面做flagrequired呢@RequestParam？

那么问题是为什么在请求视图时：

1. http://localhost:8080/gift-certificates?sort_by=name&sort_type=DESC
   请求属于这种方法。
2. http://localhost:8080/gift-certificates?sort_by=name
   不包括在这个方法中。

更新
@roman-konoval 如果注释在不同阶段起作用，为什么这不起作用？

@GetMapping
    public List<GiftCertificate> findAllAndSort(@RequestParam(value = ParameterName.SORT_BY) String sortBy,
                                                @RequestParam(value = ParameterName.SORT_TYPE, required = false) String sortType) {
        log.info("Sorting: {}, {}", sortBy, sortType);
        
return service.findAllAndSort(sortType, sortBy);
    }
    ```

我正在使用JUnit 5和H2数据库进行测试。从逻辑上讲，JUnit是单元测试，所以测试方法不应该相互依赖。另外，JUnit 以随机顺序运行测试方法。

然后出现了一个悖论。如果通过某种方法从数据库中删除了一条记录，而在另一种方法中将访问该记录，该记录已被删除，该怎么办？

我举个例子。一种方法检查是否已通过 id 从数据库表中删除记录。另一种方法是通过 id 读取该条目。

如果你设置了测试执行的顺序，那么这不再是单元测试，因为。一种测试方法依赖于另一种测试方法。

更新 1
感谢用户@andreymal 的评论

您可以在测试类上声明注释：

import org.springframework.test.annotation.DirtiesContext;

@Sql(scripts = "classpath:db/schema.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD)
@Sql(scripts = "classpath:db/data.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD)

数据库中有3张表：

• 帐户（存储用户信息）
• 公司（存储公司信息）
• 员工（存储帐户 ID 和公司 ID 以链接帐户和公司）

有一个名为Employee的同名 Java 对象，它存储在用户的会话中。目标是通过employee_id了解它属于什么类型的帐户和公司。

创建了一个带有两个参数的存储过程：company_id 和 account_id，以便在一个查询中从两个数据库表中获取信息：

// хранимая процедура, назовем её get_information
create
    definer = root@localhost procedure get_information(IN companyId bigint unsigned, IN accountID bigint unsigned)
BEGIN
    SELECT company_name, account_first_name, account_last_name, account_login
FROM accounts
INNER JOIN companies ON company_id = companyId AND account_id = accountId;
end;

更新 1：

CREATE TABLE employees (
    employee_id BIGINT UNSIGNED NOT NULL UNIQUE AUTO_INCREMENT PRIMARY KEY,
    account_id BIGINT UNSIGNED NOT NULL,
    company_id BIGINT UNSIGNED NOT NULL,
    FOREIGN KEY (account_id) REFERENCES accounts(account_id),
    FOREIGN KEY (company_id) REFERENCES companies(company_id)
);

问题 1：
JOIN 组织是否正确？如果不是，它是如何正确的？

问题2：
或者创建两个SELECT并将它们与UNION连接是否正确？

在 JSP 页面上，我设置了一个 ResourceBundle（翻译取自属性文件）并${locale}使用会话范围设置适当的语言环境变量：

<fmt:setBundle basename="locale"/>
<fmt:setLocale value="${locale}" scope="session"/>

变量的值如何设置value="${locale}"？它是在过滤器中设置的，理论上它应该在 servlet 之前工作。这是过滤器本身：

@Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
            throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        HttpSession session = request.getSession(true);

        if(session.isNew()) {
            session.setAttribute("locale", "en_US");
            LOGGER.info("Default locale page set to '{}'.", "en_US");
        }

        filterChain.doFilter(request, response);
    }

有一个过滤器HttpServletRequest从请求（英语）。HttpSessionif(session.isNew())localeen_US

过滤器本身和过滤器映射包含在web.xml其中，如下所示：

<!-- Set default locale filter -->
    <filter>
        <filter-name>DefaultLocaleFilter</filter-name>
        <filter-class>by.ct.controller.filter.DefaultLocaleFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>DefaultLocaleFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

一切似乎都井然有序。继续前行。该目录webapp包含一个index.jsp，当localhost. 就其本身而言index.jsp，存在main.jsp“从外部”无法访问的另一个页面的重定向，因为它位于/webapp/WEB-INF/jsp/main.jsp'. index.jsp 的路径中，如下所示：

<%@ taglib prefix="с" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
    <jsp:forward page="WEB-INF/jsp/main.jsp"/>
</body>
</html>

所以，一个问题实际上是什么。当我在页面上注销帐户时main.jsp，对 servlet 进行了调用，在那里确定“注销”命令已经到来，该命令被执行（它确实session.invalidate()）并forward执行（index.jsp它forward执行main.jsp）。并且在执行logout和转发之间的时间间隔内index.jsp（在forward上main.jsp），过滤器不会运行。为什么？

注销后过滤器必须工作。我试图做的（当然，这是所有的书面代码和加号）：

1. 在index.jsp我将重定向方法更改为main.jsp这种方式：

1) <jsp:forward page="WEB-INF/jsp/main.jsp"/>
2) <c:redirect url="сontroller?command=go_to_main_page"/> (через сервлет)

据我了解，在使用第二种方法时，会有一个对控制器的调用，并且由于正在调用控制器，因此过滤器会在此之前启动，但它并没有启动。我已经坐了整整2 天，今天是3，我不明白为什么设置区域设置的过滤器不起作用。

有一个带有输入字段的JSP页面，实时检查输入的有效性，并以红色突出显示块，直到输入的数据<input>不满足正则表达式条件。这一切都在街区里<form>。因此，点击按钮后，输入的信息会传输到后端，如果出现任何不正确的字段（在后端进行第二次验证），输入的数据会再次传输到页面，并且页面已经有了输入的数据。只有这里是问题 -输入错误值的字段（根据正则表达式），更新后不再突出显示错误。如何解决？
这是我所做的： validation.js：

window.onload = function(){
    const regexpAccountFirstName = /^\p{Lu}\p{Ll}{2,50}$/u;

    const accountFirstName = document.getElementById("account_first_name");

    const descriptionAccountFirstName = document.getElementById("description_account_first_name");

    accountFirstName.oninput = function() {
        if(regexpAccountFirstName.test(accountFirstName.value)) {
            descriptionAccountFirstName.style.color = "green";
        } else {
            descriptionAccountFirstName.style.color = "red";
        }
    };
};

这是正则表达式本身：

const regexpAccountFirstName = /^\p{Lu}\p{Ll}{2,50}$/u;

我们连接到 JSP 页面（我将省略额外的代码）：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ page isELIgnored="false"%>

<fmt:setLocale value="${sessionScope.locale_page}"/>
<fmt:setBundle basename="locale"/>

<html lang="en">
<head>
    <meta charset="UTF-8">


    <script src="${pageContext.request.contextPath}/js/validation.js"></script>
    <title>
        <fmt:message key="form.signUp.title"/>
    </title>
</head>
<body>
<div id="container">
    <div id="main">
        <div id="window-title" class="row"><fmt:message key="form.signUp.message"/></div>

        <form action="controller" method="post" novalidate>
            <div class="row">
                <label class="description">
                    <fmt:message key="form.signUp.warning"/>
                </label>
            </div>

            <div class="row">
                <div class="block">
                    <div class="data">
                        <span class="icon icon-user"></span>
                        <input type="text" id="account_first_name" name="account_first_name" value="${account_first_name}" placeholder="<fmt:message key="placeholder.userFirstName"/>" onblur="validationFirstName()" onchange="validationFirstName()">
                    </div>

                    <label id="description_account_first_name" class="description"><fmt:message key="description.valid.userFirstName"/></label>
                </div>
            </div>

            <div class="row">
                <button type="submit" class="button-confirm" name="command" value="sign_up"><fmt:message key="button.label.confirm"/></button>
            </div>
        </form>
    </div>
</div>

<script type="text/javascript" src="../../static/js/password.js"></script>
</body>
</html>

验证前的字段（以红色突出显示块）：

单击“确认”按钮并再次返回此验证页面后的字段（不以红色突出显示块）：

为什么像这样的正则表达式：

const validAccountFirstName = new RegExp("^\p{Lu}\p{Ll}{3,50}$");
или
const validAccountFirstName = /^\\p{Lu}\\p{Ll}{3,50}$/;

检查本身：

const accountFirstName = document.getElementById("account_first_name");
const descriptionAccountFirstName = document.getElementById("description_account_first_name");

accountFirstName.oninput = function() {
        if(validAccountFirstName.test(accountFirstName.value)) {
            descriptionAccountFirstName.style.color = "green";
        } else {
            descriptionAccountFirstName.style.color = "red";
        }
    };

在页面上根本不起作用JSP（用于输入任何字符串）？虽然它适用于regex101？

但是，像这样的正则表达式有效：

const validAccountFirstName = /^[A-Z][a-z]{3,50}$/;

validation.jsJSP 页面上的文件连接如下所示：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ page isELIgnored="false"%>

<fmt:setLocale value="${sessionScope.locale_page}"/>
<fmt:setBundle basename="locale"/>

<html lang="en">
<head>
    <meta charset="UTF-8">

    <script src="${pageContext.request.contextPath}/js/validation.js"></script>
</head>

我试过的（它不起作用）：

• 
• 
• 
• 我究竟做错了什么？

火狐 90.0（64 位）

有一个枚举：

public enum CommandType {
    LOGIN(new SignInCommand()),
    LOGOUT(new LogoutCommand());

    private Command command;

    CommandType(Command command) {
        this.command = command;
    }

    public Command getCommand() {
        return this.command;
    }
}

我想使用流来检查给定的枚举是否存在，Optional.empty()如果不存在则返回它。我这样做：

return Arrays.stream(CommandType.values())
                .filter(type -> type.name().equalsIgnoreCase(requestCommand))
                .findFirst()
                .map(CommandType::getCommand);

Optional.empty问题：如果将值传递给requestCommand不存在的变量，如何在此方法中返回enum'e？

据我所知，findFirst()返回流中的第一个元素（返回可选）。我试过这个，但它不正确：

return Arrays.stream(CommandType.values())
                .filter(type -> type.name().equalsIgnoreCase(requestCommand))
                .findFirst()
                .map(CommandType::getCommand)
                .orElse(Optional.empty());

朋友说，在他们团队接受项目时，验证者向他们指出，该对象是明确关闭的Statement。我也问了自己这个问题，然后去看看官方文档是怎么说的：

通常最好在使用完资源后立即释放资源，以避免占用数据库资源。

因此，显式关闭是一种很好的做法Statement，显然，这是通过以下方式完成的：

try {
        // работа со statemen'ом
    } catch (SQLException e) {
        LOGGER.error("Failed to execute SQL statement: {}.", SQL_PROCEDURE_CREATE_ACCOUNT);
        throw new DaoException("Failed to execute SQL statement: " + SQL_PROCEDURE_CREATE_ACCOUNT, e);
    } finally {
        try {
            statement.close();
        } catch (SQLException e) {
            //todo а если не удалось закрыть statement, что тогда делать?

            LOGGER.error("Database access error occurs when trying to close Statement object.", e);
            throw new DaoException("Database access error occurs when trying to close Statement object." + e);
        }
    }

问题：

1. statment如果尝试使用显式方法调用关闭对象时statement.close()抛出异常，如何处理对象SQLException，根据官方文档，可以在以下情况下抛出异常：

抛出：SQLException - 如果发生数据库访问错误

2. 如果对象本身实现了接口，是否还需要显式关闭statement方法调用？statement.close()StatementAutoCloseable

指定者：接口AutoCloseable中的close

安装了Tomcat。
有一个index.jsp将控制权传递给 servlet 的 JSP 页面。servlet 将该值传递给另一个名为 的 JSP 页面result.jsp。index.jsp为什么当我点击我得到的页面上的按钮时HTTP 404 error？

索引.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Index</title>
</head>
<body>
    <h4>Time counter</h4>
    <form name="Simple" action="controller" method="post">
        <input type="hidden" name="time" value="hello"/>
        <input type="submit" name="button" value="Calculate time"/>
    </form>
</body>
</html>

这是 servlet 本身：

@WebServlet("/controller")
public class Controller extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        processRequest(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        processRequest(req, resp);
    }

    private void processRequest(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        String timeFromJsp = req.getParameter("time");
        req.setAttribute("value", timeFromJsp);
        req.getRequestDispatcher("/jsp/result.jsp").forward(req, resp);
    }
}

这里result.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Result</title>
</head>
<body>
  <p>Value: ${value}</p>
</body>
</html>

目录结构是这样的：

以防万一，这里有一个例子web.xml：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!-- MAIN PAGE -->
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

    <!-- ERROR PAGE -->
    <error-page>
        <location>/jsp/error/error.jsp</location>
    </error-page>
</web-app>

我现在有这样的：

如何制作，以便在打开表格时将其分类到文件夹Columns等中Kyes。就像这里：

翻遍了设置，没找到。

我通过以下方式连接Connector/J以Maven进一步使用MySQL：

<dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>8.0.25</version>
</dependency>

DriverManager.registerDriver()必须使用将类型对象作为参数的静态方法注册驱动程序Driver。如何创建这个类型的对象Driver？

如果我 [下载][1] 一个单独jar的，那么我会这样注册：

DriverManager.registerDriver(new com.mysql.jdbc.Driver());

驱动程序名称取自文件，因此, forproperty可能有不同的驱动程序。除了这样有没有其他方法：MySqlMsSQL

String driverName = // get from property file

if(driverName.equals(com.mysql.jdbc.Driver()) {
    DriverManager.registerDriver(new com.mysql.jdbc.Driver());
} else if(driverName.equals(other_driver)) {
    DriverManager.registerDriver(new other_driver);
}


  [1]: https://dev.mysql.com/doc/connector-j/8.0/en/connector-j-installing.html

有一个Task实现接口Runnable的类，它（类）将来会成为一个线程。如何设置id这个类以供将来使用。
这是我使用的。我创建了一个Task带有指定id和覆盖方法的构造函数的类public String toString()：

public class Task implements Runnable {
    private final int id;

    static Blocker blocker = new Blocker();

    public Task(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        blocker.waitingCall();
    }

    @Override
    public String toString() {
        return "Thread (" + id + ")";
    }
}

我创建了一个线程ExecutorService：

ExecutorService exec = Executors.newCachedThreadPool();

for(int i = 0; i < 5; i++) {
    exec.execute(new Task(i));
}

接下来，我想在另一个类中的同步方法中显示id将在此方法中使用的线程，Thread.currentThread()如下所示：

synchronized void waitingCall() {
        try {
            while (!Thread.interrupted()) {
                wait();
                System.out.println(Thread.currentThread() + " from class \"" + this.getClass().getSimpleName() + "\" waiting...Zzz");
            }
        } catch (InterruptedException e) {
            System.out.println("A permissible way out");
        }
    }

但在输出我得到这条线： Thread[pool-1-thread-1,5,main] from class "Blocker" waiting...Zzz，而不是预期的Thread (id)。为什么会这样？有趣的是命名使用接口实现Runnable而不是通过类继承创建的线程的方法Thread。

为了可靠性，我将引用 Bruce Eckel 的书 - Java 哲学（第 4 版）中的引述。

我们任务的逻辑很简单：
有一个类有一个i将递增的变量和一个方法，该方法反过来会增加变量的值i。

创建类布局：

public class AtomicityTest {
    private int i = 0;

    public int getValue() {
        return this.i;
    }

    public void evenIncrement() {
        i++;
        i++;
    }
}

我们有一个变量i，将来会被多个线程访问。关于这个主题，布鲁斯·埃克尔写道：

如果多个任务同时访问一个字段，则应使用 volatile 关键字声明该字段。

好的，现在我们的类字段应该如下所示：

private volatile int i = 0;

但他在下面写道：

在 Java 虚拟机инкремент 中不是原子的......

在示例中，我们将在方法中使用атомарную自增操作++。Атомарная операция- 这是：

线程调度程序无法中断的操作 - 如果它启动，它会一直持续到完成，没有上下文切换的可能性。

我们最终会得到什么？事实证明，该操作++不是原子的，因此，声明它没有意义volatile，对吧？

阅读更多

要控制对共享资源的访问，首先将其放在对象中。之后，任何访问资源的方法都可以声明为synchronized. 这意味着如果一个任务在一个声明为同步的方法中运行，所有其他任务将无法访问它们的synchronized方法，直到第一个任务从其调用中返回。

结果，我们完成了一个类：

public class AtomicityTest implements Runnable {
    private int i = 0;

    public int getValue() {
        return this.i;
    }

    public synchronized void evenIncrement() {
        i++;
        i++;
    }

    @Override
    public void run() {
        while (true) {
            evenIncrement();
        }
    }
}

由于变量的初始值为i，0并且该方法evenIncrement()将 byединице与变量相加，因此我们最终只能得到偶数。既然方法是同步的，那么：

• 线程#1 将进入方法；
• 将阻止其他线程对该方法的访问；
• 将使变量增加2（0、2、4、6、8等）
• 线程#1 将退出并解锁其他线程对该方法的访问。

好的，现在让我们开始测试：

AtomicityTest at = new AtomicityTest();

        ExecutorService exec = Executors.newCachedThreadPool();
        exec.execute(at);

        while (true) {
            int value = at.getValue();

            if(value % 2 != 0) {
                System.out.println("value: " + value);
                System.exit(0);
            }
        }

然后奇迹。事实证明，在测试时，我们在输出端得到奇数。这怎么可能？问题的解决方案在于，返回一个i带有名称的值的方法getValue()应该像这样声明：

public synchronized int getValue() {
    ...
}

但为什么就这样呢？毕竟，一切都由上面的报价确认，并且应该在逻辑上工作，没有同步方法getValue()。

我们创建一个抽象类IntGenerator，在其中声明volatile一个类型变量boolean，其名称canceled包含最少的方法：

• next()- 生成 [-100;100] 范围内的下一个随机数；
• setCanceled()- 设置取消进一步操作的标志（见下文）。

一些理论
由于命名的变量canceled是类型的boolean，因此它是原子的（简单的操作，例如赋值和返回值，在执行期间不会中断）。

让我们更进一步
。 我们创建一个类EvenChecker，它将是一个流（简单来说），并将检查从抽象类继承的对象，其中该方法将next()生成一个奇数，设置标志以取消进一步的操作private volatile boolean canceled = false，以及进一步的操作对象应该停止。但是他们为什么不停止运行呢？

输出到控制台（程序在 10 个线程中完全处理）：

Current value: -60; EvenChecker id: 1 ; thread: by.company.test.thread.generator.EvenChecker@10818b83
Current value: -66; EvenChecker id: 4 ; thread: by.company.test.thread.generator.EvenChecker@3e369c7a
Current value: 68; EvenChecker id: 0 ; thread: by.company.test.thread.generator.EvenChecker@3fef7d6b
Current value: 87; EvenChecker id: 3 ; thread: by.company.test.thread.generator.EvenChecker@26972cd
Current value: 99; EvenChecker id: 4 ; thread: by.company.test.thread.generator.EvenChecker@3e369c7a
Current value: -65; EvenChecker id: 1 ; thread: by.company.test.thread.generator.EvenChecker@10818b83
# Value: 99 not even! EvenChecker id: 4 ; thread: by.company.test.thread.generator.EvenChecker@3e369c7a
Current value: 84; EvenChecker id: 6 ; thread: by.company.test.thread.generator.EvenChecker@3ea94c2c
Current value: 47; EvenChecker id: 6 ; thread: by.company.test.thread.generator.EvenChecker@3ea94c2c
# Value: 47 not even! EvenChecker id: 6 ; thread: by.company.test.thread.generator.EvenChecker@3ea94c2c
# Value: 87 not even! EvenChecker id: 3 ; thread: by.company.test.thread.generator.EvenChecker@26972cd
Current value: 1; EvenChecker id: 9 ; thread: by.company.test.thread.generator.EvenChecker@2ba4169e
Current value: 66; EvenChecker id: 5 ; thread: by.company.test.thread.generator.EvenChecker@313c67b1
Current value: -41; EvenChecker id: 2 ; thread: by.company.test.thread.generator.EvenChecker@74ecfb18
Current value: -92; EvenChecker id: 0 ; thread: by.company.test.thread.generator.EvenChecker@3fef7d6b
# Value: -41 not even! EvenChecker id: 2 ; thread: by.company.test.thread.generator.EvenChecker@74ecfb18
Current value: 1; EvenChecker id: 5 ; thread: by.company.test.thread.generator.EvenChecker@313c67b1
# Value: 1 not even! EvenChecker id: 9 ; thread: by.company.test.thread.generator.EvenChecker@2ba4169e
Current value: 58; EvenChecker id: 8 ; thread: by.company.test.thread.generator.EvenChecker@2596c990
Current value: -59; EvenChecker id: 7 ; thread: by.company.test.thread.generator.EvenChecker@2e20fe65
# Value: -65 not even! EvenChecker id: 1 ; thread: by.company.test.thread.generator.EvenChecker@10818b83
# Value: -59 not even! EvenChecker id: 7 ; thread: by.company.test.thread.generator.EvenChecker@2e20fe65
Current value: -12; EvenChecker id: 8 ; thread: by.company.test.thread.generator.EvenChecker@2596c990
# Value: 1 not even! EvenChecker id: 5 ; thread: by.company.test.thread.generator.EvenChecker@313c67b1
Current value: -18; EvenChecker id: 0 ; thread: by.company.test.thread.generator.EvenChecker@3fef7d6b
Current value: 51; EvenChecker id: 8 ; thread: by.company.test.thread.generator.EvenChecker@2596c990
Current value: -68; EvenChecker id: 0 ; thread: by.company.test.thread.generator.EvenChecker@3fef7d6b
# Value: 51 not even! EvenChecker id: 8 ; thread: by.company.test.thread.generator.EvenChecker@2596c990
Current value: -88; EvenChecker id: 0 ; thread: by.company.test.thread.generator.EvenChecker@3fef7d6b
Current value: -32; EvenChecker id: 0 ; thread: by.company.test.thread.generator.EvenChecker@3fef7d6b
Current value: 86; EvenChecker id: 0 ; thread: by.company.test.thread.generator.EvenChecker@3fef7d6b
Current value: -64; EvenChecker id: 0 ; thread: by.company.test.thread.generator.EvenChecker@3fef7d6b
Current value: -47; EvenChecker id: 0 ; thread: by.company.test.thread.generator.EvenChecker@3fef7d6b
# Value: -47 not even! EvenChecker id: 0 ; thread: by.company.test.thread.generator.EvenChecker@3fef7d6b

===============================================
Default Suite
Total tests run: 1, Passes: 1, Failures: 0, Skips: 0
===============================================


Process finished with exit code 0

类 IntGenerator：

public abstract class IntGenerator {
    private volatile boolean canceled = false;

    public void setCanceled() {
        canceled = true;
    }

    public boolean isCanceled() {
        return this.canceled;
    }

    public abstract int next();
}

类 SimpleGenerator：

public class SimpleIntGenerator extends IntGenerator {
    @Override
    public int next() {
        return (int) (Math.random()*(200+1)) - 100;
    }
}

类 EvenChecker：

public class EvenChecker implements Runnable {
    private final IntGenerator generator;
    private final int id;

    public EvenChecker(IntGenerator generator, int id) {
        this.generator = generator;
        this.id = id;
    }

    @Override
    public void run() {
        while (!generator.isCanceled()) {
            int value = generator.next();
            System.out.println("Current value: " + value + "; " +
                    "EvenChecker id: " + id +
                    " ; thread: " + this);

            if(value % 2 != 0) {
                System.out.println("# Value: " + value + " not even! " +
                        "EvenChecker id: " + id +
                        " ; thread: " + this);
                generator.setCanceled();
            }
        }
    }
}

运行TestNG：

@Test
    public void runEvenChecker() {
        ExecutorService executorService = Executors.newCachedThreadPool();

        // SimpleIntGenerator generator = new SimpleIntGenerator(); - так тоже не выходит
        for(int i = 0; i < 10; i++) {
            SimpleIntGenerator generator = new SimpleIntGenerator();
            executorService.execute(new EvenChecker(generator, i));
        }
    }

书中引用：

volatile 关键字还提供对应用程序更改的可见性。如果使用 volatile 关键字声明字段，这意味着在写入该字段后，所有读取操作都会“看到”更改。即使在使用本地缓存时，此声明也是正确的 - 易失性字段立即写入主内存并从主内存进行读取。

有几个Enum：

public enum Colours {
    RED, BLUE, WHITE;
}

public enum Modification {
    FULL, SIMPLE;
}

如何创建一个将任何枚举类型（或TypeColour或Modification ）作为参数并返回其类型等于参数类型的值的方法？有很多枚举，我想制作一种通用方法：

Modification mod = getAnyEnum(Modification, "SIMPLE");
// mod = Modification.SIMPLE;

или

Colours col = getAnyEnum(Colours , "RED");
// mod = Modification.SIMPLE;

要得到这样的东西：

private <E extends Enum<E>> E getAnyEnum(E type, String tagName) {
   //сделать что-то типа
   E newType = E.values(); //или метод valueOf();
   
   for(E type: list) {
       if(type.getValue.equals(tagName)) {
           return type;
       }
   }
}

我有一个Food有枚举的类Ration：

public class Food {
    private Ration  ration[] = Ration.values();       // Возвращаем массив, содержищий список констант типа Ration

public void getValue(){
        for(int i = 0; i < ration.length; i++) {
            System.out.println("Имя: " + ration[i].getName());
            System.out.println("Состояние: " + ration[i].getInclude() + "\n");
        }
    }

// Конструктор
    public Food(boolean breakfast, boolean lunch, boolean dinner, boolean supper, boolean alcohol){
        ration[0].setInclude(breakfast);
        ration[1].setInclude(lunch);
        ration[2].setInclude(dinner);
        ration[3].setInclude(supper);
        ration[4].setInclude(alcohol);
        setTotalCost();
    }
}

// Дневной рацион
enum Ration{
    // Завтрак
    BREAKFAST{
        String  name = "Завтрак";
        boolean include = false;
        int     cost    = 10;

        @Override
        public void setInclude(boolean value){
            include = value;
        }

        @Override
        public boolean getInclude() {
            return include;
        }

        @Override
        public int getCost(){
            return cost;
        }

        @Override
        public String getName(){
            return name;
        }
    },

    // Обед
    LUNCH{
        String  name = "Обед";
        boolean include = false;
        int     cost    = 11;

        @Override
        public void setInclude(boolean value){
            include = value;
        }

        @Override
        public boolean getInclude() {
            return include;
        }

        @Override
        public int getCost(){
            return cost;
        }

        @Override
        public String getName(){
            return name;
        }
    },

    // Ужин
    DINNER{
        String  name = "Ужин";
        boolean include = false;
        int     cost    = 12;

        @Override
        public void setInclude(boolean value){
            include = value;
        }

        @Override
        public boolean getInclude() {
            return include;
        }

        @Override
        public int getCost(){
            return cost;
        }

        @Override
        public String getName(){
            return name;
        }
    },

    // Прием пищи перед сном
    SUPPER{
        String  name = "Прием пищи перед сном";
        boolean include = false;
        int     cost    = 13;

        @Override
        public void setInclude(boolean value){
            include = value;
        }

        @Override
        public boolean getInclude() {
            return include;
        }

        @Override
        public int getCost(){
            return cost;
        }

        @Override
        public String getName(){
            return name;
        }
    },

    // Алкоголь
    ALCOHOL{
        String  name = "Алкоголь";
        boolean include = false;
        int     cost    = 14;

        @Override
        public void setInclude(boolean value){
            include = value;
        }

        @Override
        public boolean getInclude() {
            return include;
        }

        @Override
        public int getCost(){
            return cost;
        }

        @Override
        public String getName(){
            return name;
        }
    };

    public abstract void    setInclude(boolean value);  // включить в ассортимент
    public abstract boolean getInclude();               // получить состояние включения в ассортимент
    public abstract int     getCost();                  // получить стоимость отдельных пунктов рациона
    public abstract String  getName();                  // получить тип рациона
}

在类Main中，我创建了一个类的实例Food：

        Food food0 = new Food(false, false, false, false, false);
        Food food1 = new Food(true, false, false, false, false);
        Food food2 = new Food(true, true, false, false, false);
        Food food3 = new Food(true, true, true, false, false);
        Food food4 = new Food(true, true, true, true, false);
        Food food5 = new Food(true, true, true, true, true);

getValue()为什么我调用类方法时Food会得到所有内容true？

Имя: Завтрак
Состояние: true

Имя: Обед
Состояние: true

Имя: Ужин
Состояние: true

Имя: Прием пищи перед сном
Состояние: true

Имя: Алкоголь
Состояние: true

回答：

你不能实例化enum.

有一个方法：

public Food(boolean breakfast, boolean lunch, boolean dinner, boolean supper, boolean alcohol){
}

如何获取方法参数值的数组Food？