b2c信息网

您现在的位置是:首页 > 昨日新闻 > 正文

昨日新闻

java高并发秒杀源码(java高并发秒杀面试题)

hacker2022-09-03 09:25:16昨日新闻123
本文目录一览:1、用JAVA怎么写一个秒杀器。求具体代码2、

本文目录一览:

用JAVA怎么写一个秒杀器。求具体代码

最好不要用java写秒杀器,因为你就算用 httpclient 拿到的也是未经过渲染的html页面,很多页面js都没有加载,你根本不知道渲染之后的页面长什么样子,你最好学学木鱼的火车票抢票助手,他用的是 firefox 的插件 scriptish 来写抢票脚本,其实抢票跟秒杀是一个原理的,我第一个秒的程序就是照着他的程序改的,用这个上手也比较容易,但是要求你对javascript比较熟悉,不过比用java实现靠谱多了

java并发包源码怎么读

1. 各种同步控制工具的使用

1.1 ReentrantLock

ReentrantLock感觉上是synchronized的增强版,synchronized的特点是使用简单,一切交给JVM去处理,但是功能上是比较薄弱的。在JDK1.5之前,ReentrantLock的性能要好于synchronized,由于对JVM进行了优化,现在的JDK版本中,两者性能是不相上下的。如果是简单的实现,不要刻意去使用ReentrantLock。

相比于synchronized,ReentrantLock在功能上更加丰富,它具有可重入、可中断、可限时、公平锁等特点。

首先我们通过一个例子来说明ReentrantLock最初步的用法:

package test;

import java.util.concurrent.locks.ReentrantLock;public class Test implements Runnable{ public static ReentrantLock lock = new ReentrantLock(); public static int i = 0;

@Override public void run() { for (int j = 0; j 10000000; j++)

{ lock.lock(); try

{

i++;

} finally

{ lock.unlock();

}

}

}

public static void main(String[] args) throws InterruptedException {

Test test = new Test();

Thread t1 = new Thread(test);

Thread t2 = new Thread(test);

t1.start();

t2.start();

t1.join();

t2.join();

System.out.println(i);

}

}

有两个线程都对i进行++操作,为了保证线程安全,使用了 ReentrantLock,从用法上可以看出,与 synchronized相比,ReentrantLock就稍微复杂一点。因为必须在finally中进行解锁操作,如果不在 finally解锁,有可能代码出现异常锁没被释放,而synchronized是由JVM来释放锁。

那么ReentrantLock到底有哪些优秀的特点呢?

1.1.1 可重入

单线程可以重复进入,但要重复退出

lock.lock();

lock.lock();try{

i++;

}

finally{

lock.unlock();

lock.unlock();

}

由于ReentrantLock是重入锁,所以可以反复得到相同的一把锁,它有一个与锁相关的获取计数器,如果拥有锁的某个线程再次得到锁,那么获取计数器就加1,然后锁需要被释放两次才能获得真正释放(重入锁)。这模仿了 synchronized 的语义;如果线程进入由线程已经拥有的监控器保护的 synchronized 块,就允许线程继续进行,当线程退出第二个(或者后续) synchronized 块的时候,不释放锁,只有线程退出它进入的监控器保护的第一个synchronized 块时,才释放锁。

public class Child extends Father implements Runnable{    final static Child child = new Child();//为了保证锁唯一

public static void main(String[] args) {        for (int i = 0; i 50; i++) {            new Thread(child).start();

}

}

public synchronized void doSomething() {

System.out.println("1child.doSomething()");

doAnotherThing(); // 调用自己类中其他的synchronized方法

}

private synchronized void doAnotherThing() {        super.doSomething(); // 调用父类的synchronized方法

System.out.println("3child.doAnotherThing()");

}

@Override

public void run() {

child.doSomething();

}

}class Father {    public synchronized void doSomething() {

System.out.println("2father.doSomething()");

}

}

我们可以看到一个线程进入不同的 synchronized方法,是不会释放之前得到的锁的。所以输出还是顺序输出。所以synchronized也是重入锁

输出:

1child.doSomething()

2father.doSomething()

3child.doAnotherThing()

1child.doSomething()

2father.doSomething()

3child.doAnotherThing()

1child.doSomething()

2father.doSomething()

3child.doAnotherThing()

...

1.1.2.可中断

与synchronized不同的是,ReentrantLock对中断是有响应的。中断相关知识查看[高并发Java 二] 多线程基础

普通的lock.lock()是不能响应中断的,lock.lockInterruptibly()能够响应中断。

我们模拟出一个死锁现场,然后用中断来处理死锁

package test;import java.lang.management.ManagementFactory;import java.lang.management.ThreadInfo;import java.lang.management.ThreadMXBean;import java.util.concurrent.locks.ReentrantLock;public class Test implements Runnable{ public static ReentrantLock lock1 = new ReentrantLock(); public static ReentrantLock lock2 = new ReentrantLock(); int lock; public Test(int lock)

{ this.lock = lock;

} @Override

public void run()

{ try

{ if (lock == 1)

{

lock1.lockInterruptibly(); try

{

Thread.sleep(500);

} catch (Exception e)

{ // TODO: handle exception

}

lock2.lockInterruptibly();

} else

{

lock2.lockInterruptibly(); try

{

Thread.sleep(500);

} catch (Exception e)

{ // TODO: handle exception

}

lock1.lockInterruptibly();

}

} catch (Exception e)

{ // TODO: handle exception

} finally

{ if (lock1.isHeldByCurrentThread())

{

lock1.unlock();

} if (lock2.isHeldByCurrentThread())

{

lock2.unlock();

}

System.out.println(Thread.currentThread().getId() + ":线程退出");

}

} public static void main(String[] args) throws InterruptedException {

Test t1 = new Test(1);

Test t2 = new Test(2);

Thread thread1 = new Thread(t1);

Thread thread2 = new Thread(t2);

thread1.start();

thread2.start();

Thread.sleep(1000); //DeadlockChecker.check();

} static class DeadlockChecker

{ private final static ThreadMXBean mbean = ManagementFactory

.getThreadMXBean(); final static Runnable deadlockChecker = new Runnable()

{ @Override

public void run()

{ // TODO Auto-generated method stub

while (true)

{ long[] deadlockedThreadIds = mbean.findDeadlockedThreads(); if (deadlockedThreadIds != null)

{

ThreadInfo[] threadInfos = mbean.getThreadInfo(deadlockedThreadIds); for (Thread t : Thread.getAllStackTraces().keySet())

{ for (int i = 0; i threadInfos.length; i++)

{ if(t.getId() == threadInfos[i].getThreadId())

{

t.interrupt();

}

}

}

} try

{

Thread.sleep(5000);

} catch (Exception e)

{ // TODO: handle exception

}

}

}

};

public static void check()

{

Thread t = new Thread(deadlockChecker);

t.setDaemon(true);

t.start();

}

}

}

上述代码有可能会发生死锁,线程1得到lock1,线程2得到lock2,然后彼此又想获得对方的锁。

我们用jstack查看运行上述代码后的情况

的确发现了一个死锁。

DeadlockChecker.check();方法用来检测死锁,然后把死锁的线程中断。中断后,线程正常退出。

1.1.3.可限时

超时不能获得锁,就返回false,不会永久等待构成死锁

使用lock.tryLock(long timeout, TimeUnit unit)来实现可限时锁,参数为时间和单位。

举个例子来说明下可限时:

package test;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.ReentrantLock;public class Test implements Runnable{ public static ReentrantLock lock = new ReentrantLock(); @Override

public void run()

{ try

{ if (lock.tryLock(5, TimeUnit.SECONDS))

{

Thread.sleep(6000);

} else

{

System.out.println("get lock failed");

}

} catch (Exception e)

{

} finally

{ if (lock.isHeldByCurrentThread())

{

lock.unlock();

}

}

}

public static void main(String[] args)

{

Test t = new Test();

Thread t1 = new Thread(t);

Thread t2 = new Thread(t);

t1.start();

t2.start();

}

}

使用两个线程来争夺一把锁,当某个线程获得锁后,sleep6秒,每个线程都只尝试5秒去获得锁。

所以必定有一个线程无法获得锁。无法获得后就直接退出了。

输出:

get lock failed

1.1.4.公平锁

使用方式:

public ReentrantLock(boolean fair) public static ReentrantLock fairLock = new ReentrantLock(true);

一般意义上的锁是不公平的,不一定先来的线程能先得到锁,后来的线程就后得到锁。不公平的锁可能会产生饥饿现象。

公平锁的意思就是,这个锁能保证线程是先来的先得到锁。虽然公平锁不会产生饥饿现象,但是公平锁的性能会比非公平锁差很多。

1.2 Condition

Condition与ReentrantLock的关系就类似于synchronized与Object.wait()/signal()

await()方法会使当前线程等待,同时释放当前锁,当其他线程中使用signal()时或者signalAll()方法时,线 程会重新获得锁并继续执行。或者当线程被中断时,也能跳出等待。这和Object.wait()方法很相似。

awaitUninterruptibly()方法与await()方法基本相同,但是它并不会再等待过程中响应中断。 singal()方法用于唤醒一个在等待中的线程。相对的singalAll()方法会唤醒所有在等待中的线程。这和Obejct.notify()方法很类似。

这里就不再详细介绍了。举个例子来说明:

package test;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;public class Test implements Runnable{ public static ReentrantLock lock = new ReentrantLock(); public static Condition condition = lock.newCondition();

@Override public void run() { try

{ lock.lock();

condition.await();

System.out.println("Thread is going on");

} catch (Exception e)

{

e.printStackTrace();

} finally

{ lock.unlock();

}

}

public static void main(String[] args) throws InterruptedException {

Test t = new Test();

Thread thread = new Thread(t);

thread.start();

Thread.sleep(2000);

lock.lock();

condition.signal(); lock.unlock();

}

}

上述例子很简单,让一个线程await住,让主线程去唤醒它。condition.await()/signal只能在得到锁以后使用。

1.3.Semaphore

对于锁来说,它是互斥的排他的。意思就是,只要我获得了锁,没人能再获得了。

而对于Semaphore来说,它允许多个线程同时进入临界区。可以认为它是一个共享锁,但是共享的额度是有限制的,额度用完了,其他没有拿到额度的线程还是要阻塞在临界区外。当额度为1时,就相等于lock

下面举个例子:

package test;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Semaphore;public class Test implements Runnable{ final Semaphore semaphore = new Semaphore(5); @Override

public void run()

{ try

{

semaphore.acquire();

Thread.sleep(2000);

System.out.println(Thread.currentThread().getId() + " done");

} catch (Exception e)

{

e.printStackTrace();

}finally {

semaphore.release();

}

}

public static void main(String[] args) throws InterruptedException {

ExecutorService executorService = Executors.newFixedThreadPool(20); final Test t = new Test(); for (int i = 0; i 20; i++)

{

executorService.submit(t);

}

}

}

有一个20个线程的线程池,每个线程都去 Semaphore的许可,Semaphore的许可只有5个,运行后可以看到,5个一批,一批一批地输出。

当然一个线程也可以一次申请多个许可

public void acquire(int permits) throws InterruptedException

1.4 ReadWriteLock

ReadWriteLock是区分功能的锁。读和写是两种不同的功能,读-读不互斥,读-写互斥,写-写互斥。

这样的设计是并发量提高了,又保证了数据安全。

使用方式:

private static ReentrantReadWriteLock readWriteLock=new ReentrantReadWriteLock();

private static Lock readLock = readWriteLock.readLock();

private static Lock writeLock = readWriteLock.writeLock();

详细例子可以查看 Java实现生产者消费者问题与读者写者问题,这里就不展开了。

1.5 CountDownLatch

倒数计时器

一种典型的场景就是火箭发射。在火箭发射前,为了保证万无一失,往往还要进行各项设备、仪器的检查。 只有等所有检查完毕后,引擎才能点火。这种场景就非常适合使用CountDownLatch。它可以使得点火线程

,等待所有检查线程全部完工后,再执行

使用方式:

static final CountDownLatch end = new CountDownLatch(10);

end.countDown();

end.await();

示意图:

一个简单的例子:

package test;import java.util.concurrent.CountDownLatch;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class Test implements Runnable{ static final CountDownLatch countDownLatch = new CountDownLatch(10); static final Test t = new Test(); @Override

public void run()

{ try

{

Thread.sleep(2000);

System.out.println("complete");

countDownLatch.countDown();

} catch (Exception e)

{

e.printStackTrace();

}

}

public static void main(String[] args) throws InterruptedException {

ExecutorService executorService = Executors.newFixedThreadPool(10); for (int i = 0; i 10; i++)

{

executorService.execute(t);

}

countDownLatch.await();

System.out.println("end");

executorService.shutdown();

}

}

主线程必须等待10个线程全部执行完才会输出"end"。

1.6 CyclicBarrier

和CountDownLatch相似,也是等待某些线程都做完以后再执行。与CountDownLatch区别在于这个计数器可以反复使用。比如,假设我们将计数器设置为10。那么凑齐第一批1 0个线程后,计数器就会归零,然后接着凑齐下一批10个线程

使用方式:

public CyclicBarrier(int parties, Runnable barrierAction) barrierAction就是当计数器一次计数完成后,系统会执行的动作await()

示意图:

下面举个例子:

package test;import java.util.concurrent.CyclicBarrier;public class Test implements Runnable{ private String soldier; private final CyclicBarrier cyclic; public Test(String soldier, CyclicBarrier cyclic)

{ this.soldier = soldier; this.cyclic = cyclic;

} @Override

public void run()

{ try

{ //等待所有士兵到齐

cyclic.await();

dowork(); //等待所有士兵完成工作

cyclic.await();

} catch (Exception e)

{ // TODO Auto-generated catch block

e.printStackTrace();

}

} private void dowork()

{ // TODO Auto-generated method stub

try

{

Thread.sleep(3000);

} catch (Exception e)

{ // TODO: handle exception

}

System.out.println(soldier + ": done");

} public static class BarrierRun implements Runnable

{ boolean flag; int n; public BarrierRun(boolean flag, int n)

{ super(); this.flag = flag; this.n = n;

} @Override

public void run()

{ if (flag)

{

System.out.println(n + "个任务完成");

} else

{

System.out.println(n + "个集合完成");

flag = true;

}

}

} public static void main(String[] args)

{ final int n = 10;

Thread[] threads = new Thread[n]; boolean flag = false;

CyclicBarrier barrier = new CyclicBarrier(n, new BarrierRun(flag, n));

System.out.println("集合"); for (int i = 0; i n; i++)

{

System.out.println(i + "报道");

threads[i] = new Thread(new Test("士兵" + i, barrier));

threads[i].start();

}

}

}

打印结果:

集合

士兵5: done士兵7: done士兵8: done士兵3: done士兵4: done士兵1: done士兵6: done士兵2: done士兵0: done士兵9: done10个任务完成

1.7 LockSupport

提供线程阻塞原语

和suspend类似

LockSupport.park();

LockSupport.unpark(t1);

与suspend相比 不容易引起线程冻结

LockSupport的思想呢,和 Semaphore有点相似,内部有一个许可,park的时候拿掉这个许可,unpark的时候申请这个许可。所以如果unpark在park之前,是不会发生线程冻结的。

下面的代码是[高并发Java 二] 多线程基础中suspend示例代码,在使用suspend时会发生死锁。

而使用 LockSupport则不会发生死锁。

另外

park()能够响应中断,但不抛出异常。中断响应的结果是,park()函数的返回,可以从Thread.interrupted()得到中断标志。

在JDK当中有大量地方使用到了park,当然LockSupport的实现也是使用unsafe.park()来实现的。

public static void park() {        unsafe.park(false, 0L);

}

1.8 ReentrantLock 的实现

下面来介绍下ReentrantLock的实现,ReentrantLock的实现主要由3部分组成:

CAS状态

等待队列

park()

ReentrantLock的父类中会有一个state变量来表示同步的状态

/**

    * The synchronization state.

    */

   private volatile int state;

通过CAS操作来设置state来获取锁,如果设置成了1,则将锁的持有者给当前线程

final void lock() {            if (compareAndSetState(0, 1))

               setExclusiveOwnerThread(Thread.currentThread());            else

               acquire(1);

       }

如果拿锁不成功,则会做一个申请

public final void acquire(int arg) {        if (!tryAcquire(arg)

           acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

           selfInterrupt();

   }

首先,再去申请下试试看tryAcquire,因为此时可能另一个线程已经释放了锁。

如果还是没有申请到锁,就addWaiter,意思是把自己加到等待队列中去

其间还会有多次尝试去申请锁,如果还是申请不到,就会被挂起

private final boolean parkAndCheckInterrupt() {

       LockSupport.park(this);        return Thread.interrupted();

   }

同理,如果在unlock操作中,就是释放了锁,然后unpark,这里就不具体讲了。

2. 并发容器及典型源码分析

2.1 ConcurrentHashMap

我们知道HashMap不是一个线程安全的容器,最简单的方式使HashMap变成线程安全就是使用Collections.synchronizedMap,它是对HashMap的一个包装

public static Map m=Collections.synchronizedMap(new HashMap());

同理对于List,Set也提供了相似方法。

但是这种方式只适合于并发量比较小的情况。

我们来看下synchronizedMap的实现

它会将HashMap包装在里面,然后将HashMap的每个操作都加上synchronized。

由于每个方法都是获取同一把锁(mutex),这就意味着,put和remove等操作是互斥的,大大减少了并发量。

下面来看下ConcurrentHashMap是如何实现的

在 ConcurrentHashMap内部有一个Segment段,它将大的HashMap切分成若干个段(小的HashMap),然后让数据在每一段上Hash,这样多个线程在不同段上的Hash操作一定是线程安全的,所以只需要同步同一个段上的线程就可以了,这样实现了锁的分离,大大增加了并发量。

在使用ConcurrentHashMap.size时会比较麻烦,因为它要统计每个段的数据和,在这个时候,要把每一个段都加上锁,然后再做数据统计。这个就是把锁分离后的小小弊端,但是size方法应该是不会被高频率调用的方法。

在实现上,不使用synchronized和lock.lock而是尽量使用trylock,同时在HashMap的实现上,也做了一点优化。这里就不提了。

2.2 BlockingQueue

BlockingQueue不是一个高性能的容器。但是它是一个非常好的共享数据的容器。是典型的生产者和消费者的实现。

学习了javaweb,请问我现在可以直接学ssm吗

当然可以啊,关于ssm整合框架的学习,我在github上上传过一个小例子,通过这个小例子会让你快速学习通过ssm整合框架开发项目,里面README.md详细介绍了开发流程,让你几个小时就能学会ssm的整合与开发,附上链接: codingXiaxw/ssm 欢迎提出Issues一起改进,希望对你的学习有帮助。

另外我这边还有自己在java学习道路上写的几个很值得锻炼的小项目,如下:

我写过一个客户管理系统,由于当时没有接触框架所以使用到的技术就是JSP+Servlet+Mysql,另外对查询到的信息我使用了分页的技术,用的开发工具的IDEA,博客上详细讲解了操作流程,附上博客链接: JavaWeb项目之客户管理系统 ,源码链接为 codingXiaxw/CustomerManagement 目前已经在github上得到4个star和4个fork。

学了SSM框架后做了一个对商品信息增删改查的项目,包括SSM框架的整合详细教程,github上已经上传了我的源代码以及在README.md和博客中详细介绍了 SSM框架整合以及利用SSM框架进行开发这个项目的步骤,在此附上github链接(github的REAMDE.md中有我项目对应的博客链接,目前已经得到14个star和7个fork) codingXiaxw/ssm 另外还有在此项目上进一步进行的SSM高级知识的开发(目前已经得到6个star和7个fork),github源码和详细教程链接: codingXiaxw/ssm2

学习了Shiro框架以后,我又写了一个利用Shiro+SSM框架在上述利用SSM框架开发项目中搭建了Shiro框架,用于进行用户登录的认证以及权限管理,github上传了详细教程以及源码(目前需要你的star和fork),附上github链接: codingXiaxw/shiro

学习了Maven对项目进行管理后,又利用Maven+SSM做了一个高并发的秒杀系统,源码和详细讲解已经上传到github(目前需要你的star和fork),附上源码链接 codingXiaxw/seckill

发表评论

评论列表

  • 假欢皆叹(2022-09-03 12:59:40)回复取消回复

    继续执行。或者当线程被中断时,也能跳出等待。这和Object.wait()方法很相似。awaitUninterruptibly()方法与await()方法基本相同,但是它并不会再等待过程中响应中断。 singal()方法用于唤醒一个在等待中的线程。相

  • 可难软酷(2022-09-03 12:07:31)回复取消回复

    个简单的例子:package test;import java.util.concurrent.CountDownLatch;import java.util.concurrent.ExecutorService;import java.uti