请教个spring-mybatis mapper的线程安全问题

一般就是nginx 后面挂几个web服务器，数据库能业务上分开的一定要分开弄，可以再弄一个id生成服务器，不要依赖数据库自增张的id。扁平扩展，将来访问量上来后，增加服务器就可以了。可以使用消息队列和内存数据库处理全局共享逻辑。

一、servlet的生命周期\x0d\ 1 servlet 有种初始化情形：\x0d\ a在servlet容器启动时初始化。在webxml 中配置1表示在容器启动时初始化。默认没有此置，表示另一种情形。\x0d\ bservlet在第一次被访问时初始化。即创建唯一的servlet实例。（单例多线程下面会说）\x0d\ \x0d\ 初始化包括4个步骤：\x0d\ 1)servlet容器价值servlet类，把它的class文件读入内存 \x0d\ 2)servlet容器创建ServletConfig对象。servletConfig对象包含特定的初始化配置信息，\x0d\如s ervlet初始化参数，servlet还会是servletConfig与当前应用的ServletContext对象关联。 \x0d\ 3)servlet容器创建servlet对象\x0d\ 4)容器调用servlet对象的init(servletConfig config)方法，servlet创建完成。\x0d\ 2 当有请求访问该servlet是，servlet容器就会创建针对于这个请求的servletRequest于servletResponse，然后\x0d\servlet的service方法被调用。当容器把servlet生成的响应结果发送给客户，容器就会销毁request和response对象。\x0d\ 3 容器在销毁该实例前调用servlet的destroy方法（释放servlet所占用的资源，如关闭流和数据库连接），此外还会销毁与servlet对象关联的ServletConfig对象。\x0d\ \x0d\二、 servlet的线程安全\x0d\ 1 servlet类只创建一个实例，对于可与客户端的并发访问，它是线程不安全的。\x0d\ 2 servlet的处理方式是，每次访问时重新起一线程执行service方法。所以要想保证servlet的线程安全，不应该在servlet中定义实例变量。\x0d\ 3 当然完全可以通过加锁保证线程安全，但对于成千上万的并发访问，性能下降。

在Oracle数据库中，sequence等同于序列号，每次取的时候sequence会自动增加，一般会作用于需要按序列号排序的地方。

1、Create Sequence

(注释：你需要有CREATE SEQUENCE或CREATE ANY SEQUENCE权限)

CREATE SEQUENCE emp_sequence

INCREMENT BY 1 —— 每次加几个

START WITH 1 —— 从1开始计数

NOMAXVALUE —— 不设置最大值

NOCYCLE —— 一直累加，不循环

CACHE 10;

只要定义了emp_sequence，你就可以用使CURRVAL，NEXTVAL

CURRVAL=返回 sequence的当前值

NEXTVAL=增加sequence的值，然后返回 sequence 值

例如：

emp_sequenceCURRVAL

emp_sequenceNEXTVAL

可以使用sequence的地方：

。 不包含子查询、snapshot、VIEW的 SELECT 语句

。INSERT语句的子查询中

。NSERT语句的VALUES中

。UPDATE 的 SET中

可以看如下例子：

INSERT INTO emp VALUES

(empseqnextval, 'LEWIS', 'CLERK',7902, SYSDATE, 1200, NULL, 20);

SELECT empseqcurrval FROM DUAL;

需要注意的是：

第一次NEXTVAL返回的是初始值;随后的NEXTVAL会自动增加你定义的INCREMENT BY值，然后返回增加后的值。CURRVAL 总是返回当前SEQUENCE的值，但是在第一次NEXTVAL初始化之后才能使用CURRVAL，否则会出错。一次NEXTVAL会增加一次 SEQUENCE的值，所以如果你在同一个语句里面使用多个NEXTVAL，其值就会是不一样的。

- 假如指定CACHE值，Oracle就可以预先在内存里面放置一些sequence，这样存取的快些。cache里面的取完后，Oracle自动再取一组到cache 使用cache或许会跳号， 比如数据库突然不正常down掉(shutdown abort)，cache中的sequence就会丢失。 所以可以在create sequence的时候用nocache防止这种情况。

2、Alter Sequence

你需要有sequence的owner，或者拥有ALTER ANY SEQUENCE 权限才能改动sequence 可以alter除start至以外的所有sequence参数。如果想要改变start值，必须 drop sequence 再 re-create

Alter sequence示例：

ALTER SEQUENCE emp_sequence INCREMENT BY 10 MAXVALUE 10000 CYCLE -- 到10000后从头开始 NOCACHE ;

可以影响Sequence的初始化参数：

SEQUENCE_CACHE_ENTRIES =设置能同时被cache的sequence数目。

简单的Drop Sequence

DROP SEQUENCE order_seq;

1、java中线程同步了也就满足安全性。

2、web工程中每一个浏览器发出的>

建议先使用外部工具连接数据库试试，看是否是数据库支撑不了大规模数据的写入查询等等。检查数据库的连接数，php配置的连接数

如果是连接数满了，简单粗暴的方式，修改连接数配置。如果是mysql所消耗的内存服务问题，就要修改mysql内存，加大配置。优化一下耗时长的业务，这个和程序端的代码，是否为多线程没有太大的关系，从你发出来的情况，就是1个请求耗时太长，让后其他请求没有返回，要么是web服务内存吃紧，要么是mysql服务压力过大，连接数用满的情况，应该不太可能。

主要内容：

进程是资源分配的最小单位，每个进程都有独立的代码和数据空间，一个进程包含 1 到 n 个线程。线程是 CPU 调度的最小单位，每个线程有独立的运行栈和程序计数器，线程切换开销小。

Java 程序总是从主类的 main 方法开始执行，main 方法就是 Java 程序默认的主线程，而在 main 方法中再创建的线程就是其他线程。在 Java 中，每次程序启动至少启动 2 个线程。一个是 main 线程，一个是垃圾收集线程。每次使用 Java 命令启动一个 Java 程序，就相当于启动一个 JVM 实例，而每个 JVM 实例就是在 *** 作系统中启动的一个进程。

多线程可以通过继承或实现接口的方式创建。

Thread 类是 JDK 中定义的用于控制线程对象的类，该类中封装了线程执行体 run() 方法。需要强调的一点是，线程执行先后与创建顺序无关。

通过 Runnable 方式创建线程相比通过继承 Thread 类创建线程的优势是避免了单继承的局限性。若一个 boy 类继承了 person 类，boy 类就无法通过继承 Thread 类的方式来实现多线程。

使用 Runnable 接口创建线程的过程：先是创建对象实例 MyRunnable，然后将对象 My Runnable 作为 Thread 构造方法的入参，来构造出线程。对于 new Thread(Runnable target) 创建的使用同一入参目标对象的线程，可以共享该入参目标对象 MyRunnable 的成员变量和方法，但 run() 方法中的局部变量相互独立，互不干扰。

上面代码是 new 了三个不同的 My Runnable 对象，如果只想使用同一个对象，可以只 new 一个 MyRunnable 对象给三个 new Thread 使用。

实现 Runnable 接口比继承 Thread 类所具有的优势：

线程有新建、可运行、阻塞、等待、定时等待、死亡 6 种状态。一个具有生命的线程，总是处于这 6 种状态之一。 每个线程可以独立于其他线程运行，也可和其他线程协同运行。线程被创建后，调用 start() 方法启动线程，该线程便从新建态进入就绪状态。

NEW 状态（新建状态） 实例化一个线程之后，并且这个线程没有开始执行，这个时候的状态就是 NEW 状态：

RUNNABLE 状态（就绪状态）：

阻塞状态有 3 种：

如果一个线程调用了一个对象的 wait 方法， 那么这个线程就会处于等待状态（waiting 状态）直到另外一个线程调用这个对象的 notify 或者 notifyAll 方法后才会解除这个状态。

run() 里的代码执行完毕后，线程进入终结状态（TERMINATED 状态）。

线程状态有 6 种：新建、可运行、阻塞、等待、定时等待、死亡。

我们看下 join 方法的使用：

运行结果：

我们来看下 yield 方法的使用：

运行结果：

线程与线程之间是无法直接通信的，A 线程无法直接通知 B 线程，Java 中线程之间交换信息是通过共享的内存来实现的，控制共享资源的读写的访问，使得多个线程轮流执行对共享数据的 *** 作，线程之间通信是通过对共享资源上锁或释放锁来实现的。线程排队轮流执行共享资源，这称为线程的同步。

Java 提供了很多同步 *** 作（也就是线程间的通信方式），同步可使用 synchronized 关键字、Object 类的 wait/notifyAll 方法、ReentrantLock 锁、无锁同步 CAS 等方式来实现。

ReentrantLock 是 JDK 内置的一个锁对象，用于线程同步（线程通信），需要用户手动释放锁。

运行结果：

这表明同一时间段只能有 1 个线程执行 work 方法，因为 work 方法里的代码需要获取到锁才能执行，这就实现了多个线程间的通信，线程 0 获取锁，先执行，线程 1 等待，线程 0 释放锁，线程 1 继续执行。

synchronized 是一种语法级别的同步方式，称为内置锁。该锁会在代码执行完毕后由 JVM 释放。

输出结果跟 ReentrantLock 一样。

Java 中的 Object 类默认是所有类的父类，该类拥有 wait、 notify、notifyAll 方法，其他对象会自动继承 Object 类，可调用 Object 类的这些方法实现线程间的通信。

除了可以通过锁的方式来实现通信，还可通过无锁的方式来实现，无锁同 CAS（Compare-and-Swap，比较和交换）的实现，需要有 3 个 *** 作数：内存地址 V，旧的预期值 A，即将要更新的目标值 B，当且仅当内存地址 V 的值与预期值 A 相等时，将内存地址 V 的值修改为目标值 B，否则就什么都不做。

我们通过计算器的案例来演示无锁同步 CAS 的实现方式，非线程安全的计数方式如下：

线程安全的计数方式如下：

运行结果：

线程安全累加的结果才是正确的，非线程安全会出现少计算值的情况。JDK 15 开始，并发包里提供了原子 *** 作的类，AtomicBoolean 用原子方式更新的 boolean 值，AtomicInteger 用原子方式更新 int 值，AtomicLong 用原子方式更新 long 值。 AtomicInteger 和 AtomicLong 还提供了用原子方式将当前值自增 1 或自减 1 的方法，在多线程程序中，诸如 ++i 或 i++ 等运算不具有原子性，是不安全的线程 *** 作之一。 通常我们使用 synchronized 将该 *** 作变成一个原子 *** 作，但 JVM 为此种 *** 作提供了原子 *** 作的同步类 Atomic，使用 AtomicInteger 做自增运算的性能是 ReentantLock 的好几倍。

上面我们都是使用底层的方式实现线程间的通信的，但在实际的开发中，我们应该尽量远离底层结构，使用封装好的 API，例如 JUC 包（javautilconcurrent，又称并发包）下的工具类 CountDownLath、CyclicBarrier、Semaphore，来实现线程通信，协调线程执行。

CountDownLatch 能够实现线程之间的等待，CountDownLatch 用于某一个线程等待若干个其他线程执行完任务之后，它才开始执行。

CountDownLatch 类只提供了一个构造器：

CountDownLatch 类中常用的 3 个方法：

运行结果：

CyclicBarrier 字面意思循环栅栏，通过它可以让一组线程等待至某个状态之后再全部同时执行。当所有等待线程都被释放以后，CyclicBarrier 可以被重复使用，所以有循环之意。

相比 CountDownLatch，CyclicBarrier 可以被循环使用，而且如果遇到线程中断等情况时，可以利用 reset() 方法，重置计数器，CyclicBarrier 会比 CountDownLatch 更加灵活。

CyclicBarrier 提供 2 个构造器：

上面的方法中，参数 parties 指让多少个线程或者任务等待至 barrier 状态；参数 barrierAction 为当这些线程都达到 barrier 状态时会执行的内容。

CyclicBarrier 中最重要的方法 await 方法，它有 2 个重载版本。下面方法用来挂起当前线程，直至所有线程都到达 barrier 状态再同时执行后续任务。

而下面的方法则是让这些线程等待至一定的时间，如果还有线程没有到达 barrier 状态就直接让到达 barrier 的线程执行任务。

运行结果：

CyclicBarrier 用于一组线程互相等待至某个状态，然后这一组线程再同时执行，CountDownLatch 是不能重用的，而 CyclicBarrier 可以重用。

Semaphore 类是一个计数信号量，它可以设定一个阈值，多个线程竞争获取许可信号，执行完任务后归还，超过阈值后，线程申请许可信号时将会被阻塞。Semaphore 可以用来 构建对象池，资源池，比如数据库连接池。

假如在服务器上运行着若干个客户端请求的线程。这些线程需要连接到同一数据库，但任一时刻只能获得一定数目的数据库连接。要怎样才能够有效地将这些固定数目的数据库连接分配给大量的线程呢？

给方法加同步锁，保证同一时刻只能有一个线程去调用此方法，其他所有线程排队等待，但若有 10 个数据库连接，也只有一个能被使用，效率太低。另外一种方法，使用信号量，让信号量许可与数据库可用连接数为相同数量，10 个数据库连接都能被使用，大大提高性能。

上面三个工具类是 JUC 包的核心类，JUC 包的全景图就比较复杂了：

JUC 包（javautilconcurrent）中的高层类（Lock、同步器、阻塞队列、Executor、并发容器）依赖基础类（AQS、非阻塞数据结构、原子变量类），而基础类是通过 CAS 和 volatile 来实现的。我们尽量使用顶层的类，避免使用基础类 CAS 和 volatile 来协调线程的执行。JUC 包其他的内容，在其他的篇章会有相应的讲解。

Future 是一种异步执行的设计模式，类似 ajax 异步请求，不需要同步等待返回结果，可继续执行代码。使 Runnable（无返回值不支持上报异常）或 Callable（有返回值支持上报异常）均可开启线程执行任务。但是如果需要异步获取线程的返回结果，就需要通过 Future 来实现了。

Future 是位于 javautilconcurrent 包下的一个接口，Future 接口封装了取消任务，获取任务结果的方法。

在 Java 中，一般是通过继承 Thread 类或者实现 Runnable 接口来创建多线程， Runnable 接口不能返回结果，JDK 15 之后，Java 提供了 Callable 接口来封装子任务，Callable 接口可以获取返回结果。我们使用线程池提交 Callable 接口任务，将返回 Future 接口添加进 ArrayList 数组，最后遍历 FutureList，实现异步获取返回值。

运行结果：

上面就是异步线程执行的调用过程，实际开发中用得更多的是使用现成的异步框架来实现异步编程，如 RxJava，有兴趣的可以继续去了解，通常异步框架都是结合远程 >

以上就是关于请教个spring-mybatis mapper的线程安全问题全部的内容，包括:请教个spring-mybatis mapper的线程安全问题、java问题，servlet问题，servlet在什么时候被初始化它是线程安全吗、oracle sequence 线程安全吗等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！