代码

一级目录

class PrintChar  implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            System.out.println('s');
        }
    }
}
class PrintNum implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            System.out.println('A');
        }
    }
}
public class Test {
    public static void main(String[] args) {
        PrintChar s = new PrintChar();
        PrintNum  a = new PrintNum();
        Thread ts = new Thread(s);
        Thread ta = new Thread(a);
        ts.start();//任意形式交替进行
        ta.start();
    }
}

单线程

package com;

class PringChar  implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            Thread.yield();
            System.out.print('c');
        }
    }
}
class PrintNumb implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            if ( i==1 ){
                Thread f = new Thread(new Print$());
                f.start();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    f.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.print(i);
        }
    }
}
class Print$ implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.print("$");
        }
    }
}
public class Test {
    public static void main(String[] args) {
        PringChar c = new PringChar();
        PrintNumb n = new PrintNumb();

        Thread tc = new Thread(c);
        Thread tn = new Thread(n);

        tc.start();

        tn.start();
    }


}

线程

package com;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class PringChar  implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            Thread.yield();
            System.out.print('c');
        }
    }
}
class PrintNumb implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            if ( i==1 ){
                Thread f = new Thread(new Print$());
                f.start();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    f.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.print(i);
        }
    }
}
class Print$ implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.print("$");
        }
    }
}
public class Test {
    public static void main(String[] args) {
        PringChar c = new PringChar();
        PrintNumb n = new PrintNumb();
        //线程池
        ExecutorService executorService = Executors.newFixedThreadPool(2);//创建一个有2个空白线程的线程池。

        executorService.execute(c);//将c放入其中一个空白线程
        executorService.execute(n);

        executorService.execute(new Print$());

//        executorService.shutdown();//关闭线程池
//        executorService.shutdownNow();//立即关闭
//        executorService.isShutdown();//如果执行器以关闭，则返回true
//        executorService.isTerminated();//如果池中的所有任务终止，则返回true
    }


}

package com;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class AccountWithoutSync implements Runnable{

    private static Account account = new Account();
    @Override
    public void run() {
        account.deposit(1);
    }
}
class Account{
    public static int balance;
    public static int getBalance(){
        return balance ;
    }
    //synchronized
    public synchronized void deposit(int amount){
        int newBalance = balance + amount;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        balance = newBalance;
    }
}

class AddMany implements Runnable{
    @Override
    public void run() {

    }
}

public class Tests {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i <100 ; i++) {
            executorService.execute(new AccountWithoutSync());


        }
        executorService.shutdown();
        while (! executorService.isTerminated());
        System.out.println(Account.getBalance());
    }
}

101 生产者和消费着

package com;

import java.util.LinkedList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//java 101


public class ConsumerProducer {
    private static Buffer buffer = new Buffer();
//生产着
    private static class ProducerTask implements Runnable {

        @Override
        public void run() {

            try {
                int i = 1;
                while (true) {
                    System.out.println("Producer writes" + i);
                    buffer.write(i++);


                    Thread.sleep((int) (Math.random() * 1000));

            }  } catch(InterruptedException e){
            e.printStackTrace();
        }
        }
    }
//消费着
    private static class ConsumerTask implements Runnable{

    @Override
    public void run() {
        try {
            while (true) {
                System.out.println("\t\tConsumer reads" + buffer.read());
                Thread.sleep((int) (Math.random() * 1000));
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
//作多线程时，优先考虑临界资源区的书写
    private static class Buffer {
        private static final int CAPACITY = 1;//仓库容量只有一个元素
        private final LinkedList<Integer> queue = new LinkedList<>();//相当于存放生产内容的仓库
        private final static Lock lock = new ReentrantLock();//为真，公平锁，
        private final static Condition notEmpty = lock.newCondition();
        private final static Condition notFull = lock.newCondition();

        public void write(int value) {//往集合中写入一个元素value
            lock.lock();//上锁
            try {
                while (queue.size() == CAPACITY) {//仓库满了
                    System.out.println("wait for notFull condition");//当代非满条件
                    notFull.await();//阻塞

                }
                queue.offer(value);//往集合里面写元素,入队列
                notEmpty.signal();//释放

            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();//解锁
            }
        }

        public int read() {
            int value = 0;
            lock.lock();
            try {
                while (queue.isEmpty()) {//队列如果是空的
                    System.out.println("\t\t\tWait for notEmpty condition");
                    notEmpty.await();
                }
                    value = queue.remove();//出队列
                    notFull.signal();//释放
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
                return value;
            }
        }
    }

    public static void main(String[] args) {
        new Thread(new ProducerTask()).start();
        new Thread(new ConsumerTask()).start();
    }

//    public static void main(String[] args) {
//        ExecutorService executor = Executors.newFixedThreadPool(2);
//        executor.execute(new ProducerTask());
//        executor.execute(new ConsumerTask());
//        executor.shutdown();
//    }

}

101 阻塞队列 java自带合集

package com;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConsumerProducer {
    private static ArrayBlockingQueue buffer = new ArrayBlockingQueue(1);

    //生产着
    private static class ProducerTask implements Runnable {

        @Override
        public void run() {

            try {
                int i = 1;
                while (true) {
                    System.out.println("Producer writes" + i);
                    buffer.put(i++);
                    Thread.sleep((int) (Math.random() * 5000));
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //消费着
    private static class ConsumerTask implements Runnable {
        @Override
        public void run() {
            try {
                while (true) {
                    System.out.println("\t\tConsumer reads" + buffer.take());
                    Thread.sleep((int) (Math.random() * 5000));
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.execute(new ProducerTask());
        executor.execute(new ConsumerTask());
        executor.shutdown();
    }

}

网络

package com;

import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
//服务器
public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(20000);//这是一个服务器，对外开放20000端口；
        Socket socket = serverSocket.accept();//accept方法是阻塞的，即停在这里等待客户端的连接；
        //Socket   是一个套接字，里面放的是来自于客户端的IP地址和端口号。
        try (OutputStream output = socket.getOutputStream()){
            output.write("hell,word".getBytes());

        }

    }
}
package com;

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
//客户端
public class Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1",20000);//127.0.0.1 回环地址
        try (InputStream input = socket.getInputStream()
        ){
            byte[] bytes = new byte[input.available()];
            input.read(bytes);
            System.out.println(new String(bytes));

        }

    }
}
// 获得网址基本信息
package com;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class Identify {
    public static void main(String[] args) throws UnknownHostException {
        InetAddress address = InetAddress.getByName("baidu.com");
        //获得这个网址的基本信息
        System.out.println(address.getHostAddress());//获得ip
        System.out.println(address.getHostName());//获得主机名
    }

JDBC

JDBC API中常见的类：
DriverManager 驱动管理器类，用于管理驱动程序
Connection 表示打开的一个数据库连接
Statement 这个类用于执行一条SQL语句
ResultSet 用于存放SELECT语句的查询结果

PreparedStatement 当一个SQL语句不完整时，可以考虑使用。他被称为预备语句，或预定义语句。

package com;

import java.sql.*;

public class Test {
    public static void main(String[] args) {
        //1.必须先加载驱动
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //2.建立数据库连接              //驱动，管理器
        try (Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","my-secret-pw")){

            //3.准备执行一条语句，加测试。
            Statement statement = connection.createStatement();//建立Statement对象，准备执行sql语句

        //    statement.execute("CREATE TABLE students();");
            statement.executeUpdate("CREATE TABLE students(id int,name varchar (20))");
            //executeUpdate用来执行除SELECT之外的所有SQL语句
            statement.executeUpdate("insert into students(id,name )values (1,'Tom')");
            int i =statement.executeUpdate("insert into students(id,name)values (2,'Jerry')");
            //此处的i就表示这句话影响了几行
            ResultSet resultSet = statement.executeQuery("SELECT *FROM students");
            //executeQuery专门用于执行SELECT语句
            //ResultSet表示SELECT的查询结果存放的类

            while (resultSet.next()){
                System.out.println(resultSet.getInt(1)+resultSet.getString(2));
            }

        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

javaScript

<!DOCTYPE html>  <!-- 这是html的标志 -->
<html lang="en">     <!-- 每个HTML 程序都要以<html>开始，以</html>结束 -->
<head>     <!-- 网页头部开始  -->
    <meta charset="UTF-8">   <!-- 字符编码 -->
    <title>Title</title>  <!-- 标题内容 -->
</head>   <!-- 网页头部结尾 -->
<body>   <!-- 网页的内容开始 -->
<from>
    编号<input id="id">
    姓名<input id="name">
    年龄<input id="age">
    <input id="button" type="button" value="添加">
</from>
<table border="1" id="t">
    <tr>
        <td>编号</td>
        <td>姓名</td>
        <td>年龄</td>
    </tr>
</table>

</body>    <!-- 网页的内容结束 -->
<script>
    function f() {
        var id = document.getElementById("id").value;
        var name = document.getElementById("name").value;
        var age = document.getElementById("age").value;
        var tr = document.createElement("tr");//建立一个新的HTML元素tr;
        var td1 = document.createElement("td");
        td1.innerText = id;//innerText指列中的内容
        var td2 = document.createElement("td");
        td2.innerText = name;
        var td3 = document.createElement("td");
        td3.innerText = age;
        tr.append(td1);//append是将一个元素放入另一个元素的里面
        tr.append(td2);
        tr.append(td3);
        document.getElementById("t").append(tr);
    }
        document.getElementById("button").onclick = f;

</script>




</html>    <!-- 这是html 结束的标志 -->

javax.servlet.*;

package com;

import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import java.io.IOException;

@WebServlet(urlPatterns = "/my")//这/my一个调用这个程序的超链接，必须以/开头
//当一个项目中有很多Servlet时，他们的urlPatterns必须不同；
public class MySevlet implements Servlet {

    private ServletConfig servletConfig;

    @Override  //init方法在第一次调用servlet时自动执行一次，之后再也不执行了
    public void init(ServletConfig servletConfig) throws ServletException {
    this.servletConfig=servletConfig;
        System.out.println("init执行");
    }
    @Override //service方法在每次调用servlet时都会自动执行
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("service执行");
    }

    @Override //destroy方法在Tomcat容器关闭前执行一次
    public void destroy() {
        System.out.println("destroyyyyyy");
    }

    @Override//这个方法返回一个字符串，这个字符串返回的是这个类的作用，啥作用，自己写
    public String getServletInfo() {
        return "你的月";
    }

    @Override//这个方法是为了获得一个init方法中的那个参数
    public ServletConfig getServletConfig() {
        return servletConfig;
    }

}

简单连接WEB 11

package com;

import com.entity.Student;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
//超链接
@WebServlet(urlPatterns = "/jdbc")
public class jdbcServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        int minAge = Integer.parseInt(req.getParameter("minAge"));
        int maxAge = Integer.parseInt(req.getParameter("maxAge"));


        try(Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mysql","root","my-secret-pw")){

          //  Statement statement = connection.createStatement();

           PreparedStatement preparedStatement =  connection.prepareStatement("select * from students where ? and ?");

           preparedStatement.setInt(1,minAge);
           preparedStatement.setInt(2,maxAge);

            ResultSet resultSet = preparedStatement.executeQuery();//查询出来的结果
            List<Student> students = new ArrayList<>();

            while (resultSet.next()){
                Student student = new Student(
                        resultSet.getInt(1),
                        resultSet.getString(2),
                        resultSet.getInt(3),
                        resultSet.getString(4),
                        resultSet.getString(5)


                        );
                students.add(student);
            }


			//将值起好名字后放入req中
            req.setAttribute("students",students);
            //转发 ，从servlet中转发到students.jsp中
            req.getRequestDispatcher("students.jsp").forward(req,resp);
            
			// 1。request指的是一次请求，类似于发短信
			//req.setAttribute("名字",值)；
			
			// 2.session指的是一次会话，类似与一次聊天，只要不关闭浏览器，数据就一直存在       
			// HttpSession session = req.getSession();//获得一个session(会话)			
			//session.setAttribute("名字",值)；
			
			//3.ServletContext上下文，只要不关掉Tomcat,数据就一直存在。
			//ServletContext context = req.getServletContext();
			//context.setAttribute("名字“，值);

        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

}

package com.entity;

public class Student {
    private int id;
    private String name;
    private int age;
    private String sex;
    private String mobile;

    public Student() {
    }

    public Student(int id, String name, int age, String sex, String mobile) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.mobile = mobile;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getSex() {
        return sex;
    }

    public String getMobile() {
        return mobile;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void setMobile(String mobile) {
        this.mobile = mobile;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", mobile='" + mobile + '\'' +
                '}';
    }
}

<%--
  Created by IntelliJ IDEA.
  User: l
  Date: 2020/7/13
  Time: 下午3:19
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="jdbc">
    <input  name="minAge"/>~<input name="maxAge"/>
    <input type="submit" value="Search">
</form>





</body>
</html>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
  Created by IntelliJ IDEA.
  User: l
  Date: 2020/7/13
  Time: 下午1:16
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<table border="1px">
    <tr>
    <td>id</td>
        <td>name</td>
        <td>age</td>
        <td>sex</td>>
        <td>mobile</td>
    </tr>
    <c:forEach var="student" items="${students}">
    <tr>
        <td>${student.id}</td>
        <td>${student.name}</td>
        <td>${student.age}</td>
        <td>${student.sex}</td>
        <td>${student.mobile}</td>


    <
    /tr>
    </c:forEach>
</body>
</html>

标题
private StudentDao studentDao = new StudentDaoImpl<>();创建studentDao对象
Integer.parseInt(); 转型
req.getParameter(“id”) ； 取值/取客户端的值
List students = studentDao.select(id); studentDao调用查询方法的结果
select(id)；查询方法
req.setAttribute(“student”, students.get(0));将值起好（名字随便起），存到req中
req.getRequestDispatcher(“update.jsp”).forward(req, resp); //转发 跳转到update.jsp网页中

Student student = new Student();
studentDao.update(student);
resp.sendRedirect(“findAll”);重定向

@WebServlet(urlPatterns = "/toUpdate")
public class UpdateStudentServlet extends HttpServlet {
    private StudentDao studentDao = new StudentDaoImpl<>();
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        int id = Integer.parseInt(req.getParameter("id"));   
        List<Student> students = studentDao.select(id);
        req.setAttribute("student", students.get(0));
        req.getRequestDispatcher("update.jsp").forward(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Student student = new Student(
                Integer.parseInt(req.getParameter("id")),
                req.getParameter("name"),
                Integer.parseInt(req.getParameter("age")),
                req.getParameter("sex"),
                req.getParameter("mobile")
        );
        studentDao.update(student);
        resp.sendRedirect("findAll");
    }