Java从入门到精通 第22章 多线程

最新推荐文章于 2022-04-16 11:14:31 发布
最新推荐文章于 2022-04-16 11:14:31 发布
阅读量158 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AnalogElectronic/article/details/104657913
版权

Java从入门到精通 第22章 多线程

//单一线程的运行流程
public class Nanjing {
    
    public static void main(String[] args) {
    	
    	// TODO, add your application code
    	System.out.println("Hello World!");
    	//new TestThread.run();书上这样写的，会报错，找不到符号
    	TestThread tt=new TestThread();
    	tt.run();
    	new TestThread().run();//这种写法也是可以的
    	for(int i=0;i<5;i++)
    		System.out.println("main is runing");
    }
}

class TestThread{
	public void run(){
		for(int i=0;i<5;i++)
			System.out.println("TestThread is Running...");
	}
}

Hello World!
TestThread is Running…
TestThread is Running…
TestThread is Running…
TestThread is Running…
TestThread is Running…
main is runing
main is runing
main is runing
main is runing
main is runing

22.2.1 通过继承Thread类实现多线程

//同时激活多个线程
public class Nanjing {
    
    public static void main(String[] args) {
    	
    	// TODO, add your application code
    	System.out.println("Hello World!");
    	new TestThread().start();//隐式的创建是可以的
    	for(int i=0;i<5;i++)
    	{
    		System.out.println("main is runing");
    		try{
    			Thread.sleep(1000);
    		}catch(InterruptedException e){
    			e.printStackTrace();
    		}
    	}
    }
}

class TestThread extends Thread{
	public void run(){
		for(int i=0;i<5;i++)
		{
			System.out.println("TestThread is Running...");
			try{
				Thread.sleep(1000);
			}catch(InterruptedException ex){
				ex.printStackTrace();
			}
		}
	}
}

Hello World!
main is runing
TestThread is Running…
main is runing
TestThread is Running…
main is runing
TestThread is Running…
main is runing
TestThread is Running…
main is runing
TestThread is Running…

22.2.2 通过继承Runnable接口实现多线程

public class Nanjing {
    
    public static void main(String[] args) {
    	
    	// TODO, add your application code
    	System.out.println("Hello World!");
    	TestThread t=new TestThread();
        new Thread(t).start();
    	for(int i=0;i<5;i++)
    	{
    		System.out.println("main is runing");
    		try{
    			Thread.sleep(1000);
    		}catch(InterruptedException e){
    			e.printStackTrace();
    		}
    	}
    }
}

class TestThread implements Runnable{
	public void run(){
		for(int i=0;i<5;i++)
		{
			System.out.println("TestThread is Running...");
			try{
				Thread.sleep(1000);
			}catch(InterruptedException ex){
				ex.printStackTrace();
			}
		}
	}
}

Hello World!
main is runing
TestThread is Running…
TestThread is Running…
main is runing
main is runing
TestThread is Running…
main is runing
TestThread is Running…
TestThread is Running…
main is runing

22.2.3 两种多线程实现机制的比较

本质上，Thread类是Runnable接口的一个子类

public class Nanjing {
    
    public static void main(String[] args) {
    	
    	TestThread t=new TestThread();
    	t.start();
    	t.start();//一个线程只能启动一次
    }
}

class TestThread extends Thread{
	private int ticketes=5;
	public void run(){
		while(ticketes>0){
			System.out.println(Thread.currentThread().getName()+" Saling ticket"+ticketes);
			ticketes-=1;
		}
	}
}

Thread-0 Saling ticket5
Thread-0 Saling ticket4
Thread-0 Saling ticket3
Thread-0 Saling ticket2
Thread-0 Saling ticket1
Exception in thread “main” java.lang.IllegalThreadStateException
at java.lang.Thread.start(Thread.java:571)
at Test.main(Test.java:7)

//创建三个线程同时售票
public class Nanjing {
    
    public static void main(String[] args) {
    	
    	new TestThread().start();
    	new TestThread().start();
    	new TestThread().start();
    }
}

class TestThread extends Thread{
	private int ticketes=5;
	public void run(){
		while(ticketes>0){
			System.out.println(Thread.currentThread().getName()+" Saling ticket"+ticketes);
			ticketes-=1;
		}
	}
}

Thread-1 Saling ticket5
Thread-1 Saling ticket4
Thread-1 Saling ticket3
Thread-1 Saling ticket2
Thread-1 Saling ticket1
Thread-0 Saling ticket5
Thread-0 Saling ticket4
Thread-0 Saling ticket3
Thread-0 Saling ticket2
Thread-0 Saling ticket1
Thread-2 Saling ticket5
Thread-2 Saling ticket4
Thread-2 Saling ticket3
Thread-2 Saling ticket2
Thread-2 Saling ticket1
//实际上Thread很难达到资源共享的目的，但是可以通过静态变量达到资源共享

//Runnble相对于Thread有优势
①避免Java单继承带来的局限
②可以使多个线程共享相同的资源，以达到资源共享之目的

public class Nanjing {
    
    public static void main(String[] args) {
    	TestThread t=new TestThread();
    	new Thread(t).start();
    	new Thread(t).start();
    	new Thread(t).start();
    }
}

class TestThread implements Runnable{
	private int ticketes=5;
	public void run(){
		while(ticketes>0){
			System.out.println(Thread.currentThread().getName()+" Saling ticket"+ticketes);
			ticketes-=1;
		}
	}
}

//result
Thread-0 Saling ticket5
Thread-0 Saling ticket4
Thread-0 Saling ticket3
Thread-0 Saling ticket2
Thread-0 Saling ticket1

22.3 线程的状态

//演示线程的生命周期
import java.util.Scanner;
public class Nanjing {
    
    public static void main(String[] args) {
    	Thread t=new Thread(new TestThread());
    	System.out.println("Thead is at build state");
    	t.start();
    	System.out.println("Ready state");
    }
}

class TestThread implements Runnable{
	private int ticketes=5;
	public void run(){
			System.out.println("Runing...");
			Scanner scanner=new Scanner(System.in);
			System.out.println("Waiting I/O,Blocking");
			System.out.println("Please input String:");
			scanner.next();
			scanner.close();
			System.out.println("Block over,Re-enter the ready state and then enter the running state");
			try{
				Thread.sleep(1000);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
			System.out.println("Thread enter dead state");
		}
}

//result
Thead is at build state
Ready state
Runing…
Waiting I/O,Blocking
Please input String:
Naning science and technology institute//输入完后停顿了1秒
Block over,Re-enter the ready state and then enter the running state
Thread enter dead state

22.4 线程操作的一些方法

22.4.1取得和设置线程名称

//线程名称的操作
public class Nanjing {
    
    public static void main(String[] args) {
    	TestThread t=new TestThread();
    	t.start();
    	for(int i=0;i<3;i++){
    		t.printMsg();
    		try{
    			Thread.sleep(1000);
    		}catch(InterruptedException e){
    			e.printStackTrace();
    		}
    	}
    }
}

class TestThread extends Thread{
	public void run(){
		for(int i=0;i<3;i++){
			printMsg();
			try{
				Thread.sleep(1000);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
	}
	public void printMsg(){
		Thread t=Thread.currentThread();//获得运行此代码的线程的引用
		String name=t.getName();
		System.out.println("name="+name);
	}
}

//result
name=main
name=Thread-0
name=main
name=Thread-0
name=main
name=Thread-0

//设置线程名称
t.setName("BIT");

//判断线程是否启动
t.isAlive()

22.4.3守护线程与setDaemon方法

ThreadTest t=new ThreadTest();
Treat tt=newThread(t);
tt.setDaemon(true);//设置守护线程，一定要在start()之前
tt.start();
//主线程main结束就随之终止了
//当java虚拟机中没有非守护线程在运行的时候，java虚拟机会关闭。当所有常规线程运行完毕以后，守护线程不管运行到哪里，虚拟机都会退出运行。所以你的守护线程最好不要写一些会影响程序的业务逻辑。否则无法预料程序到底 会出现什么问题。

22.4.4 线程的联合

//演示线程的强制执行
ThreadTest t=new ThreadTest(t);
pp.start();
int i=0;
for(int x=0;x<5;x++)
if(i==3)
try{
pp.join();//强制运行完pp线程后，再运行后面的进程，使主线程暂时挂起
}

22.4.5 线程的中断

//线程中断的使用范例
public class Nanjing {
    
    public static void main(String[] args) {
		TestThread tt=new TestThread();
		Thread t=new Thread(tt);
		t.start();
		try{
			Thread.sleep(2000);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		System.out.println("at main()method,interrupt other thread");
		t.interrupt();
		System.out.println("at main()method,exit");
    }
}

class TestThread implements Runnable{
	public void run(){
		try{
			System.out.println("at run() method,let this thread sleep 10 seconds");
			Thread.sleep(10000);
			System.out.println("at run() method,continue runing");
		}catch(InterruptedException x){
			System.out.println("at run() method,interrupt thread");
			return;
		}
		System.out.println("at run() method,continue to complete after sleep");
		System.out.println("at run() method,normally exit");
	}
}

//result
at run() method,let this thread sleep 10 seconds
at main()method,interrupt other thread
at run() method,interrupt thread
at main()method,exit

22.5多线程的同步

同步代码块
synchronized{
}

//同步代码块的使用
public class Nanjing {
    
    public static void main(String[] args) {
		TestThread tt=new TestThread();
		new Thread(tt).start();
		new Thread(tt).start();
		new Thread(tt).start();
    }
}

class TestThread implements Runnable{
	private int tickets=5;
	public void run(){
		while(true){
			synchronized (this){
				if(tickets<=0) break;
				try{
					Thread.sleep(1000);
				}catch(Exception e){
					e.printStackTrace();
				}
			}
			System.out.println(Thread.currentThread().getName()+"saling ticket"+tickets);
			tickets-=1;
		}
	}
}

//result
Thread-0saling ticket5
Thread-1saling ticket4
Thread-2saling ticket3
Thread-1saling ticket2
Thread-0saling ticket1
Thread-1saling ticket0

同步方法
public sychoronized void sale(){}

//同步方法的使用
public class Nanjing {
    
    public static void main(String[] args) {
		TestThread tt=new TestThread();
		new Thread(tt).start();
		new Thread(tt).start();
		new Thread(tt).start();
    }
}

class TestThread implements Runnable{
	private int tickets=5;
	public void run(){
		while(tickets>0){
			sale();
		}
	}
	public synchronized void sale(){
		if(tickets>0){
			try{
				Thread.sleep(1000);
			}catch(Exception e){
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+" saling ticket"+tickets);
			tickets-=1;
		}
	}
}

Thread-0 saling ticket5
Thread-2 saling ticket4
Thread-1 saling ticket3
Thread-0 saling ticket2
Thread-2 saling ticket1

22.5.4死锁

如果一组进程，其中的每个都无限等待该组进程中的另一个进程所占据的资源，就会产生无限期的僵持下去的局面，这种现象就是死锁

Java多线程中，最常见的死锁形式是当线程1已经占据资源R1，并持有资源R1上的锁，而正在等待资源2开锁；而线程2已经占据资源R2，并且持有R2上的锁，正在等待资源R1开锁。如果俩个线程不释放自己占据的资源锁，而还申请对方资源上的锁，申请不到时就等待，那么他们只能永远等待下去

//模拟死锁的发生
public class DeadLock{
	static String knife="knife",fork="fork";
	static class A extends Thread{
		public void run(){
			synchronized(knife){
				System.out.println("A take "+knife+", waiting "+fork+"...");
				try{
					Thread.sleep(100);
				}catch(InterruptedException e){}
				synchronized(fork){//由于死锁的原因，这里永远不会执行
					System.out.println("A take "+fork);
				}
			}
		}
	}
	static class B extends Thread{
		public void run(){
			synchronized(fork){
				System.out.println("B take "+fork+", waiting for "+knife+"...");
				try{
					Thread.sleep(1000);
				}catch(InterruptedException e){}
				synchronized(knife){
					System.out.println("B take knife");
				}	
			}
		}
	}
	static class Demo extends Thread{
		public Demo(){
			this.setDaemon(true);
		}
		public void run(){
			while(true){
				try{
					Thread.sleep(1000);
				}catch(InterruptedException e){}
				System.out.println("protected thread:program is running...");
			}
		}
	}
	public static void main(String[] args){
		new A().start();
		new B().start();
		new Demo().start();
	}
}

//result
A take knife, waiting fork…
B take fork, waiting for knife…
protected thread:program is running…
protected thread:program is running…
protected thread:program is running…
protected thread:program is running…

22.6线程间的通信

22.6.1问题的引出

一个线程向数据存储空间中添加数据（生产者），另一个线程从数据空间中取出数据（消费者）。这个程序有两种以外需要考虑。
第一种以外，假设生产者线程刚向数据存储空间中添加了一个人的姓名，还没有加入这个人的性别，CPU就切换到了消费者线程，消费者线程则把这个人的姓名和上一个人的性别联系到了一起

第二种意外，生产者放入了若干数据，消费者才开始读取数据，或者是消费者读取完一个数据后，还没等到生产者放入新的数据，又重新取出已经取过的数据。

在操作系统里，上面的案例属于经典的同步问题——生产者消费者问题
可以过线程间的通信来解决以上问题

//进程间的通信
class Producer implements Runnable{
	Person p=null;
	public Producer(Person p){
		this.p=p;
	}
	public void run(){
		for(int i=0;i<10;i++){
			if(i%2==0){
				p.name="ZhangSan";
				try{
					Thread.sleep(1000);
				}catch(InterruptedException e){
					e.printStackTrace();
				}
				p.sex="male";
			}else{
				p.name="LiSi";
				try{
					Thread.sleep(1000);
				}catch(InterruptedException e){
					e.printStackTrace();
				}
				p.sex="female";
			}
		}
	}
}

class Consumer implements Runnable{
	Person q=null;
	public Consumer(Person q){
		this.q=q;
	}
	public void run(){
		for(int i=0;i<10;i++){
			System.out.println(q.name+"--->"+q.sex);
			try{
				Thread.sleep(1000);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
	}
}

class Person{
	String name="LiSi";
	String sex="female";
}
public class Test{
	public static void main(String[] args){
		Person q=new Person();
		new Thread(new Producer(q)).start();
		new Thread(new Consumer(q)).start();
	}
}

//result
ZhangSan—>female
ZhangSan—>female
LiSi—>male
ZhangSan—>female
ZhangSan—>female
LiSi—>male
LiSi—>male
ZhangSan—>female
LiSi—>male
ZhangSan—>female

//进程同步的使用
class Producer implements Runnable{
	Person p=null;
	public Producer(Person p){
		this.p=p;
	}
	public void run(){
		for(int i=0;i<10;i++){
			if(i%2==0){
				p.set("ZhangSan","male");
			}else{
				p.set("LiSi","male");
			}
		}
	}
}

class Consumer implements Runnable{
	Person q=null;
	public Consumer(Person q){
		this.q=q;
	}
	public void run(){
		for(int i=0;i<10;i++){
			q.get();
		}
	}
}

class Person{
	String name="LiSi";
	String sex="female";
	public synchronized void set(String name,String sex){
		this.name=name;
		this.sex=sex;
	}
	public synchronized void get(){
		System.out.println(this.name+"--->"+this.sex);
	}
}
public class Test{
	public static void main(String[] args){
		Person q=new Person();
		new Thread(new Producer(q)).start();
		new Thread(new Consumer(q)).start();
	}
}

//result
LiSi—>male
LiSi—>male
LiSi—>male
LiSi—>male
LiSi—>male
LiSi—>male
LiSi—>male
LiSi—>male
LiSi—>male
LiSi—>male
//example analysis
虽然保证了李四是女的，但是又产生了另外的问题，Consumer线程对Producer线程放入的数据连续的读取多次，多次输出：Lisi—>male这并不符合实际要求。合理的结果是Producer放入一次数据，Consumer就取一次；反之。Producer必须等到Consumer取完后才能放入新的数据，而这一问题就需要线程通信

Java通过Object类的wait() noify() notifyAll()这几个发方法来实现线程通信
wait() 通知当前线程进入睡眠状态
notify()唤醒在该同步代码块中第一个调用的wait()的线程
ntifyAll()唤醒该同步代码块中所有调用wait()的线程，具有高优先级的线程首先被唤醒并执行

//线程通信问题的解决
class Producer implements Runnable{
	Person p=null;
	public Producer(Person p){
		this.p=p;
	}
	public void run(){
		for(int i=0;i<10;i++){
			if(i%2==0){
				p.set("ZhangSan","male");
			}else{
				p.set("LiSi","female");
			}
		}
	}
}

class Consumer implements Runnable{
	Person q=null;
	public Consumer(Person q){
		this.q=q;
	}
	public void run(){
		for(int i=0;i<10;i++){
			q.get();
		}
	}
}

class Person{
	String name="LiSi";
	String sex="female";
	private boolean bFull=false;
	public synchronized void set(String name,String sex){
		if(bFull){
			try{
				wait();//后来的线程要等待
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
		this.name=name;
		this.sex=sex;
		bFull=true;
		notify();//唤醒最先达到的线程
	}
	public synchronized void get(){
		if(!bFull){
			try{
				wait();
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
		System.out.println(this.name+"--->"+this.sex);
		bFull=false;
		notify();
	}
}

public class Test{
	public static void main(String[] args){
		Person q=new Person();
		new Thread(new Producer(q)).start();
		new Thread(new Consumer(q)).start();
	}
}

//result
ZhangSan—>male
LiSi—>female
ZhangSan—>male
LiSi—>female
ZhangSan—>male
LiSi—>female
ZhangSan—>male
LiSi—>female
ZhangSan—>male
LiSi—>female

22.8总结

1.线程的几个特点
（1）同步代码块和同步方法锁的是对象，而不是代码。即如果某个对象被同步代码块或同步方法锁住，那么其他使用该对象的代码必须等待，直到该对象的锁被释放
（2）如果一个进程只有后台进程，则这个进程就会结束
（3）每个已经被创建的线程在结束之前均会处于就绪、运行、阻塞状态之一

2.另外一种多线程同步的锁机制
java.util.concurrent.locks

3.Java 8新引入Lambda表达式

AnalogElectronic
关注
专栏目录
Java从入门到精通 第十二章 异常处理
zhengzaifeidelushang的博客
12-15 216
Java从入门到精通 第十二章 异常处理 一、处理程序异常错误 Java语言的异常捕获结构由try、catch和finally三部分组成。try语句块存放的是可能发生异常的Java语句。catch程序块在try语句块之后，用来激发被捕获的异常；finally语句块是异常处理结构的最后执行部分，无论try语句块中的代码如何退出，都将执行finally语句块。 语法如下： try{ //程序代码块 } catch(Exception1 e){ //对Exceptiontype1的处理 } catch(Exc
java零基础从入门到精通（全）
热门推荐
码农研究僧的博客
07-18 4万+
目录前言1. 入门知识1.1 java体系1.2 JDK/JRE/JVM区别1.3 编译与运行理解1.4 类体函数细节2. 标识符 前言 java优势 健壮性（JVM（C++语言写的一个虚拟的计算机）、GC（垃圾回收机制）） 多线程并发 可移植性/跨平台 1. 入门知识 1.1 java体系 JavaSE：标准版 JavaEE：企业版 JavaME：微型版 1.2 JDK/JRE/JVM区别 JVM是不能独立安装的。 JRE和JDK都是可以独立安装的 层层嵌套，jvm包括jdk，jdk包括jre
Java 多线程 -- 从入门到精通
程序员小哲的博客
11-04 6431
Java 多线程 -- 从入门到精通Java线程与线程的区别多线程的实现方法Thread中start和run方法的区别Thread和Runnable的关系使用Callable和Future创建线程线程返回值的处理方法线程的六个状态线程不安全解决线程不安全（synchronized）sleep和wait的区别 Java线程与线程的区别 线程是CPU调度的最小单位，进程是资源分配的最小单位。 多线程的实现方法 继承Thread类，重写run方法 实现Runnable接口，重写run方法 通过Callable和
java从入门到精通学习笔记（四）——多线程
qq_33004293的博客
10-27 471
一、线程 状态：新建、运行（可运行）、阻塞、等待、计时等待、终止 对于单处理器的系统，虽然说是多线程并发执行，但同一时间点上只有一个线程被执行。 二、实现线程的两种方式 1. 继承java.lang.Thread类  (1) Thread类的构造函数： public Thread(String threadName);  //参数为线程对象的名称 public Thread(
java从入门到精通 十八章 多线程
qq_33135813的博客
05-26 445
多线程这个概念在经过一段时间的开发后，考虑接口等问题的时候很容易考虑到。比如做电商系统中库存抢购，车票购买的时候如何控制等问题，根本原因就在于一个多线程安全问题，本章提出的解决方法时通过同步代码快的方式，将多线程异步问题 改为多线程同步，这样无论下单的是谁,都是经过一笔一笔单子来处理，这样就不会出现多线程等问题.当然也可以通过消息队列等方式来控制，下单的时候都需要排队，或者通过其他方式实现多线程并...
20190119——Java从入门到精通 第十八章 多线程
寄蜉蝣于天地，渺沧海之一粟。
01-19 313
如果一次只完成一件事情，就会很容易实现，但现实生活中很多事情都是同时进行的，所以在java中为了模拟这种状态，引入了线程机制，简单的说，当程序同时完成多件事情，就是所谓的多线程程序，多线程应用相当广泛，使用多线程可以创建窗口程序，网络程序等。 线程简介 世间万物都可以同时完成很多工作，例如，人体可以同时进行呼吸、血液循环、思考问题等活动。用户既可以使用计算机听歌，也可以使用它打印文件，而这些活动完...
Java多线程入门到精通，小白也能快速入门
xxsiyao的博客
06-27 301
多线程的概述：即同时做多件事情；一个服务器可以让多个人同时访问。 进程的概述：在一个操作系统中，每个独立执行的程序都可称之为一个进程，也就是“正在运行的程序”。 在以上图示中，在一个程序中多个线程执行图，看似同时进行，其实是由CPU调度，CPU的运行速度很快，所以看起来像是同时执行的。 在Java中提供了实现多线程的两种方式：一种是继承java.lang包下的Thread类，覆写Thread类的run()方法，在run()方法中实现运行在线程上的代码；另一种是实现java.lang.Runnable接口.
JAVA多线程基础篇
北漂的PHPcoder
07-21 210
JAVA多线程篇线程CPU并行并发JAVA中的多线程线程间数据共享AQSCASSringBoot 中应用多线程 线程 进程、线程、协程的概念在多个语言中都有不同的提现，例如JAVA中存在进程+主线程+子线程的概念，GO中的进程+主线程+协程的概念，PHP中的进程+主线程都有不用的解决方案，但是我们还是要明确各个名词的概念 CPU 并行 并发 JAVA中的多线程 线程间数据共享 AQS CAS SringBoot 中应用多线程 ...
java 从入门到精通.zip
最新发布
03-07
本资料“Java从入门到精通”旨在帮助初学者系统地学习Java语言，逐步掌握其核心概念和技术。 一、Java基础知识 1.1 Java简介：了解Java的历史、特点和应用领域，认识Java平台的三个版本（J2SE、J2EE、J2ME）。 1.2 ...
java从入门到精通第一章到底二十四章
08-19
"Java从入门到精通第一章到底二十四章"这个教程涵盖了从基础到进阶的全方位Java知识，旨在为初学者提供一个系统的学习路径。 首先，第一章通常会介绍Java的历史、特点和应用领域，以及为什么选择Java作为学习对象。...
java从入门到精通(第三版)光盘实例
10-18
《Java从入门到精通》（第三版）是一本旨在帮助初学者和有一定基础的程序员深入理解Java编程语言的书籍。光盘实例作为该书的重要补充，提供了丰富的代码示例和实际应用，帮助读者巩固理论知识并提升实战技能。在这些...
SpringBoot中JSONObject 和 JSONArray的请求解析
AnalogElectronic的博客
10-22 3221
package springboot.controller; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframew
springboot整合mybatis-plus多数据源分别连接mysql和oracle
AnalogElectronic的博客
09-07 2518
一、引入依赖 <dependency> <groupId>com.oracle</groupId> <artifactId>ojdbc6</artifactId> <version>11.2.0.3</version> </dependency> <!-- MYBATIS PLUS -->
JAVA service层参数校验
AnalogElectronic的博客
04-16 1891
package springboot.domain; import cn.afterturn.easypoi.excel.annotation.Excel; import com.alibaba.excel.annotation.ExcelIgnore; import com.alibaba.excel.annotation.ExcelProperty; import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.m
oracle学习笔记01
AnalogElectronic的博客
11-14 947
02.oracle体系结构 1、数据库 oracle数据库是数据的物理存储，包括数据文件ORA或DBF、控制文件、联机文件、参数文件。oracle数据库概念和其他数据库不一样，这里的数据库是一个操作系统只有一个库。 2、实例 一个oracle实例（oracle instance）有一系列的后台进程（background process）和内存结构（memory structure）组成，一个数据库可以有n个实例。 3、数据文件（dbf） 数据文件是数据库物理存储单位，数据库的数据是存在表空间中的，真正是在某
mysql索引对查询效率的影响
AnalogElectronic的博客
12-16 921
文章目录数据准备创建一张表创建随机生成姓名的函数创建新增n条数据的存储过程表里插入两千万条数据没索引有索引 数据准备 创建一张表 create table student ( s_id varchar(64) not null primary key, s_name varchar(20) default '' not null, s_birth varchar(20) default '' not null, s_sex varchar(10) d
一个简单的前后端分离案例
AnalogElectronic的博客
03-06 801
一、IDEA 建一个spring boot 工程，只要spring web依赖即可 二、写一个测试接口 package com.example.demo; import org.springframework.web.bind.annotation.CrossOrigin; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestContr
maven项目中操作mysql数据库案例
AnalogElectronic的博客
03-24 719
MAVEN_HOME D:\Program File\apache-maven-3.3.9 PATH;%MAVEN_HOME%\bin project object model pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" ...
java文件处理
AnalogElectronic的博客
03-27 668
文件字节流 //从C盘拷贝图片到D盘 import java.io.*; public class Test{ public static void main(String[] args) { FileInputStream fis=null; FileOutputStream fos=null; File f=new File("c:\\a.jpg"); try { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值