South-

Java多线程复习笔记

1、基础概要
2、线程死锁
3、读写的脏读问题
4、锁的重入性
5、线程中的异常处理与锁的关系
6、volatile关键字
7、CountDownLatch
8、ReentrantLock
9、生产者消费者问题
10、ThreadLocal
11、多窗口售票问题
12、几种并发Map的使用

12.1、ConcurrentHashMap
12.2、ConcurrentSkipListMap

13、几种List的使用

13.1、ArrayList
13.2、Vector
13.3、CopyOnWriteArrayList
13.4、Collections.synchronizedList

14、几种Queue的使用

14.1、ConcurrentLinkedQueue
14.2、LinkedBlockingQueue
14.3、ArrayBlockingQueue
14.4、DelayQueue
14.5、LinkedTransferQueue
14.6、SynchronousQueue

15、线程池

15.1、newFixedThreadPool
15.2、newCachedThreadPool
15.3、newSingleThreadExecutor
15.4、newScheduledThreadPool
15.5、newWorkStealingPool
15.6、ForkJoinPool
15.7、parallelStream

16、FutureTask

1、基础概要

Java线程的创建方法有三种，第一种是通过实现Runnable接口，第二种是通过继承Thread类本身，第三种是通过 Callable 和 Future 来创建线程。第一种和第二种，都是通过重写run方法，来实现线程的执行实例。并通过start方法启动线程。第三种方法后文再做详细描述。

2、线程死锁

Java是通过synchronized关键字实现线程同步的，调用是synchronized(this){代码块}。在这里，我们需要明白，synchronized申请的锁this是一个class对象，this是为了大多数情况下方便调用，你可以将任意类型的Object对象替代这个this，来实现线程同步。Attention：同步代码块中的语句越少越好，所以有些无任何安全性问题的代码，可以放在同步代码块之外。

下面我们通过一段代码来理解线程死锁，线程A申请a的锁，在过程中，还会申请b的锁，线程B申请b的锁，在过程中，还会申请a的锁，这样就形成了一个等待死锁，A线程在等待B线程结束释放b锁，B线程在等待A线程结束释放A锁。注意样例中创建线程处的两处，是使用的Lambda表达式，具体使用可以百度查阅。

public class T{
	
	Object a=new Object();
	Object b=new Object();

	void a(){
		synchronized (a) {
			System.out.println(Thread.currentThread().getName()+" start ...");
			try {
				TimeUnit.SECONDS.sleep(2);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (b) {
				
			}
			System.out.println(Thread.currentThread().getName()+" end ...");
		}
	}
	
	void b() {
		synchronized (b) {
			System.out.println(Thread.currentThread().getName()+" start ...");
			try {
				TimeUnit.SECONDS.sleep(2);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (a) {
				
			}
			System.out.println(Thread.currentThread().getName()+" end ...");
		}
	}

	public static void main(String[] args) {
		T t=new T();
		new Thread(t::a,"线程A").start();
		new Thread(()->t.b(),"线程B").start();
	}

}

3、读写的脏读问题

在比较常见的读写问题中，如果只对写方法加锁，对读方法不加锁，就可能产生脏读问题，以下代码为例：

public class T{
	
	Integer data;
	
	Integer get() {
		return data;
	}
	
	synchronized void set() {
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		data=1;
	}

	public static void main(String[] args) throws InterruptedException {
		T t=new T();
		new Thread(t::set).start();
		TimeUnit.SECONDS.sleep(1);
		System.out.println("data = " + t.get());
		TimeUnit.SECONDS.sleep(2);
		System.out.println("data = " + t.get());
	}

}

运行结果：可以看出，当写操作中存在一些耗时操作时，如果对读操作不进行加锁，就可能存在脏读问题。

4、锁的重入性

一个同步方法中调用另一个同步方法，如果该线程已经拥有了某个对象的锁，进行调用时，仍然可以。同样，子类调用父类也是可以的。描述的有点抽象，还是通过代码来感受下吧。可以看到，子类对象线程在已经拥有了锁时，调用父类方法，并不会形成阻塞，调用类中另一个同步方法同样如此。

public class T{
	
	synchronized void test1() throws InterruptedException {
		System.out.println("父类调用test1开始");
		TimeUnit.SECONDS.sleep(2);
		test2();
		System.out.println("父类调用test1结束");
	}
	
	synchronized void test2() {
		System.out.println("父类调用test2");
	}

	public static void main(String[] args) throws InterruptedException {
		T t=new TT();
		new Thread(() -> {
			try {
				t.test1();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}).start();
	}

}

class TT extends T{
	
	synchronized void test1() throws InterruptedException {
		System.out.println("子类调用开始");
		super.test1();
		System.out.println("子类调用结束");
	}
	
}

5、线程中的异常处理与锁的关系

在线程方法中，如果遇到异常，没有进行异常捕捉处理，锁将会主动释放，如果进行了异常处理，则不会因为异常而让出锁。对比以下两种情况下的结果，图1未做异常处理，在执行到异常时，主动释放锁给其他线程，线程B得以执行；图2做了异常处理，所以不会将锁释放给其他线程，形成阻塞。

6、volatile关键字

volatile变量具有可见性，即使得变量每次在使用时，从主存中获取，而不是从线程的工作内存中取，synchronized关键字具有可见性和原子性，原子性能够保证数据同步，volatile变量仅具有可见性，所以它并不能保证线程并发的正确性。下面从一个案例中尝试理解volatile的作用，运行发现，方法线程并不会因为主线程中，running的值的更改，而结束循环使得线程正常结束，会永远得停留在循环里面。想要让running的值的更改，能够被方法线程获取到正确的修改后的running值，需要加上volatile关键字修饰running变量，即volatile boolean running=true。

public class T {
	
	boolean running=true;
	
	void m() {
		System.out.println("Start.......");
		while (running) {
			
		}
		System.out.println("Ending........");
	}
	
	public static void main(String[] args) {
		T t =new T();
		new Thread(t::m,"方法线程").start();
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t.running=false;
		System.out.println("Main end");
	}

}

volatile不能替代synchronized，保证程序并发正确性的体现案例：线程正确并发的输出结果应该是10*1000000，而实际运行结果并不是这个，可见volatile不能保证线程的并发正确性。

class T {
    volatile int count=0;
    void m(){
        for (int i = 0; i < 1000000; i++) {
            count++;
        }
    }

    public static void main(String[] args) {
        T t=new T();

        List<Thread> threads=new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            threads.add(new Thread(t::m,"thread-"+i));
        }

        threads.forEach((o)->o.start());

        threads.forEach((o)->{
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println(t.count);
    }
}

上面已经讲了volatitle关键字，它只有可见性，没有原子性，所以不能保证线程并发的正确性。所以以上案例的累加结果出现错误。此种情况下，可以使用AtomicInteger来实现多线程累加，它是通过原子方式更新的 int值。相似的类还有AtomicBoolean，AtomicLong等，详情查询API文档。

public class Test {
	
	AtomicInteger sum=new AtomicInteger(0);
	
	void doAdd() {
		for(int i=0;i<1000;i++)
			sum.incrementAndGet();
	}
	
	public static void main(String[] args) {
		
		Test test=new Test();
		List<Thread> threads=new ArrayList<Thread>();
		for(int i=0;i<10;i++) {
			threads.add(new Thread(test::doAdd));
		}
		threads.forEach((thread)->thread.start());
		threads.forEach((thread)->{
			try {
				thread.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});
		System.out.println("The sum is "+test.sum.get());
	}

}

7、CountDownLatch

一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。用给定的计数初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await方法会一直受阻塞。之后，会释放所有等待的线程，await的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用CyclicBarrier。CountDownLatch是一个通用同步工具，它有很多用途。将计数 1 初始化的 CountDownLatch用作一个简单的开/关锁存器，或入口：在通过调用countDown()的线程打开入口前，所有调用 await的线程都一直在入口处等待。用 N 初始化的 CountDownLatch可以使一个线程在 N 个线程完成某项操作之前一直等待，或者使其在某项操作完成 N 次之前一直等待。CountDownLatch的一个有用特性是，它不要求调用 countDown方法的线程等到计数到达零时才继续，而在所有线程都能通过之前，它只是阻止任何线程继续通过一个 await。

下面通过一个题目来对CountDownLatch进行一次简单的理解运用。题目描述：实现一个容器，提供两个方法add和size，写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束。为了避免线程2一直死循环监听浪费CPU，可以用CountDownLatch来解决。

public class T{
	
	volatile List<Integer> nums=new ArrayList<Integer>();
	CountDownLatch lock=new CountDownLatch(1);

	void add() {
		System.out.println("线程1开始");
		for(int i=0;i<10;i++) {
			nums.add(i);
			System.out.println(nums.get(i));
			if(nums.size()==5) {
				lock.countDown();
			} 
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("线程1结束");
		
	}
	
	void size(){
		System.out.println("线程2开始");
		try {
			lock.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("线程2结束");
	}
	

	public static void main(String[] args) {
		T t=new T();
		
		new Thread(t::size,"线程2").start();
		
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		new Thread(t::add,"线程1").start();
		
	}


}

8、ReentrantLock

Reentrantlock可以用于替代synchronized，而且它使用的时候，必须要手动释放锁，使用synchronized锁定的话如果遇到异常，jvm会自动释放锁，但是lock必须手动释放锁，因此我们经常在finally中进行锁的释放。

基本使用样例：

public class ReentrantLockTest {
	
	Lock lock=new ReentrantLock();
	
	void methodA() {
		try {
			lock.lock();
			System.out.println("Method A start ...");
			TimeUnit.SECONDS.sleep(2);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
			System.out.println("Method A end ...");
		}
	}
	
	void methodB() {
		try {
			lock.lock();
			System.out.println("Method B start ...");
			TimeUnit.SECONDS.sleep(2);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
			System.out.println("Method B end ...");
		}
	}

	public static void main(String[] args) throws InterruptedException {	
		ReentrantLockTest test=new ReentrantLockTest();
		new Thread(test::methodA).start();
		TimeUnit.SECONDS.sleep(2);
		new Thread(test::methodB).start();
	}

}

我们还可以使用tryLock()方法来尝试申请锁，无论方法返回值是true还是false，后面的代码都会执行，可以根据返回值来进行判断，做相应的处理。还可以对tryLock进行时间限制，即在指定时间内，是否能申请到锁，如tryLock(3,TimeUnit.SECONDS)表示尝试在3S内申请锁，3S后返回申请的结果。

public class ReentrantLockTest {
	
	Lock lock=new ReentrantLock();
	
	void methodA() {
		try {
			lock.lock();
			System.out.println("Method A start ...");
			TimeUnit.SECONDS.sleep(10);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
			System.out.println("Method A end ...");
		}
	}
	
	void methodB() {
		boolean flag=false;
		try {
			flag=lock.tryLock();//尝试获取锁，无论申请到与否，都会执行下面的方法
			System.out.println("Method B try to get the lock "+(flag==true?"success":"failed"));
			if(flag==true) {
				System.out.println("Method B start ...");	
			}else {
				System.out.println("Method B end without getting the lock");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			if(flag==true) lock.unlock();
		}
	}

	public static void main(String[] args) throws InterruptedException {	
		ReentrantLockTest test=new ReentrantLockTest();
		new Thread(test::methodA).start();
		TimeUnit.SECONDS.sleep(2);
		new Thread(test::methodB).start();
	}

}

lockInterruptibly方法，如果当前线程未被中断，则获取锁，如果锁可用，则获取锁，如果锁不可用，出于线程调优的目的，将禁用当前线程，下面演示一个当前线程锁不可用的例子。

public class ReentrantLockTest {
	
	Lock lock=new ReentrantLock();
	
	void methodA() {
		try {
			lock.lock();
			System.out.println("Method A start ...");
			TimeUnit.SECONDS.sleep(10);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
			System.out.println("Method A end ...");
		}
	}
	
	void methodB() {
		try {
			lock.lockInterruptibly();
		} catch (Exception e) {
			System.out.println("Method B was interrupted ...");
		}
	}

	public static void main(String[] args) throws InterruptedException {	
		ReentrantLockTest test=new ReentrantLockTest();
		Thread a=new Thread(test::methodA);
		a.start();
		TimeUnit.SECONDS.sleep(2);
		Thread b=new Thread(test::methodB);
		b.start();
		TimeUnit.SECONDS.sleep(1);
		b.interrupt();
	}

}

ReentrantLock还可以指定公平锁，在介绍它的应用之前，我们先简单理解一下什么是公平锁和非公平锁。公平锁即一个新线程发出请求时，这个锁真被其他线程占有，或者还有其他线程也在等待，它会选择进入队列中等候。非公平锁即一个新线程在申请一个被其他线程占用的锁时，当这个锁释放了，它会立即抢夺，而不需排队等候。非公平锁的性能要比公平锁的性能高，因为在恢复一个被挂起的线程与该线程真正运行之间存在着严重的延迟。下面介绍它的使用。

public class ReentrantLockTest {
	
	Lock lock=new ReentrantLock(true);
	
	void method() {
		for(int i=0;i<50;i++) {
			try {
				lock.lock();
				System.out.println(Thread.currentThread().getName()+"抢夺到了该锁");
				TimeUnit.SECONDS.sleep(1);
			} catch (Exception e) {
				e.printStackTrace();
			}finally {
				lock.unlock();
			}
		}
	}

	public static void main(String[] args) throws InterruptedException {	
		ReentrantLockTest test=new ReentrantLockTest();
		new Thread(test::method,"线程1").start();
		new Thread(test::method,"线程2").start();
	}

}

实例化一个ReentrantLock对象时，传入一个参数true即可将之指定为公平锁，从上面的运行结果可以看出，线程1和线程2轮流获得锁的权限。

9、生产者消费者问题

题目描述：假定有10个消费者线程，2个生产者线程，容器的最大容量为10，生产者不停生产，消费者不停消费，试着设计一个程序来解决该问题。

解法一：使用基本的wait,notify,notifyAll来形成线程之间的阻塞和等待。

public class T {
	
	static final int MAX=10;
	volatile LinkedList<String> container=new LinkedList<>();
	volatile int i=0;
	
	void produce() {
		while(true) {
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (container) {
				while(getCount()==MAX) {
					try {
						container.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				String s="产品"+i+"号";
				container.add(s);
				System.out.println(Thread.currentThread().getName()+"生产了"+s+",当前库存"+getCount());
				i++;
				container.notifyAll();	
			}
		}	
	}
	
	void consume() {
		while(true) {
			try {
				TimeUnit.SECONDS.sleep(3);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (container) {
				String result=null;
				while(getCount()==0) {
					try {
						container.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				System.out.println(Thread.currentThread().getName()+"消费了"+
						container.removeFirst()+",剩余库存"+getCount());
				container.notifyAll();
			}	
		}
	}
	
	synchronized int getCount() {
		return container.size();
	}

	public static void main(String[] args) {
		
		T t=new T();
		List<Thread> consumes=new ArrayList<Thread>();
		List<Thread> produces=new ArrayList<Thread>();
		for(int j=0;j<10;j++) {
			consumes.add(new Thread(t::consume,"消费者"+j+"号"));
		}
		for(int j=0;j<2;j++) {
			consumes.add(new Thread(t::produce,"生产者"+j+"号"));
		}
		consumes.forEach(o->o.start());
		produces.forEach(o->o.start());
	}

}

解法二：使用Lock和Condition来解决。

public class T {
	
	static final int MAX=10;
	volatile LinkedList<String> container=new LinkedList<>();
	volatile int i=0;
	ReentrantLock lock=new ReentrantLock();
	Condition produce=lock.newCondition();
	Condition consume=lock.newCondition();
	
	void produce() {
		while(true) {
			try {
				lock.lock();
				if(getCount()==MAX) produce.await();
				TimeUnit.SECONDS.sleep(1);
				String s="产品"+i+"号";
				container.add(s);
				System.out.println(Thread.currentThread().getName()+"生产了"+s+",当前库存"+getCount());
				i++;	
				consume.signalAll();
			}catch (Exception e) {
				e.printStackTrace();
			}finally {
				lock.unlock();
			}		
		}	
	}
	
	void consume() {
		while(true) {
			try {
				lock.lock();
				if(getCount()==0) consume.await();
				TimeUnit.SECONDS.sleep(3);
				System.out.println(Thread.currentThread().getName()+"消费了"+
						container.removeFirst()+",剩余库存"+getCount());	
				produce.signalAll();
			}catch (Exception e) {
				e.printStackTrace();
			}finally {
				lock.unlock();
			}		
		}	
	}
	
	synchronized int getCount() {
		return container.size();
	}

	public static void main(String[] args) {
		
		T t=new T();
		List<Thread> consumes=new ArrayList<Thread>();
		List<Thread> produces=new ArrayList<Thread>();
		for(int j=0;j<10;j++) {
			consumes.add(new Thread(t::consume,"消费者"+j+"号"));
		}
		for(int j=0;j<2;j++) {
			consumes.add(new Thread(t::produce,"生产者"+j+"号"));
		}
		consumes.forEach(o->o.start());
		produces.forEach(o->o.start());
	}

}

10、ThreadLocal

ThreadLocal用于代表线程的局部变量，首先我们先通过一段代码来演示一种两个线程之间对同一个数据的读写的可能情况。

public class T{
	
	String value=new String("修改前");
	
	void a() {
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(value);
	}
	
	void b() {
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		value=new String("修改后");
	}
	
	
	public static void main(String[] args){
		T t=new T();
		new Thread(t::a).start();
		new Thread(t::b).start();
	}

}

运行输出的结果为“修改后”，因为线程A睡眠时间比线程B长，在线程A输出value的值的时候，value的值已经被线程B给修改了。在某些情况下，我们并不想因为一个线程中对对象作出了修改而影响到其他对象，比如一个游戏，一个玩家的行为有时候并不会影响到其他玩家，这个时候我们可以使用ThreadLocal来实现。

public class T{
	
	ThreadLocal<String> value=new ThreadLocal<String>();
	
	void a() {
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(value.get());
	}
	
	void b() {
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(value.get());
		value.set("修改后");
		System.out.println(value.get());
	}
	
	
	public static void main(String[] args){
		T t=new T();
		new Thread(t::a).start();
		new Thread(t::b).start();
	}

}

运行结果如下：

11、多窗口售票问题

问题描述：假如一个车站有10个售票窗口，车站共计有100张票，所有窗口一起工作，设计一到程序来模拟窗口售票的过程。

错误解法：我们使用ArrayList来存放车票，因为ArrayList它是不安全的，线程并发过程中可能存在问题，出现ArrayIndexOutOfBoundsException异常。

public class T{
	
	static List<String> tickets=new ArrayList<String>();
	
	static {
		for(int i=1;i<=100;i++) {
			tickets.add(new String("编号"+i+"的车票"));
		}
	}
	
	void sale() {
		while(tickets.size()>0) {
			try {
				TimeUnit.MILLISECONDS.sleep(100);//睡眠100ms
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"销售了"+tickets.remove(0));
		}
	}
	
	
	public static void main(String[] args){
		T t=new T();
		List<Thread> conductors=new ArrayList<Thread>();
		for(int i=1;i<=10;i++) {
			conductors.add(new Thread(t::sale,i+"号窗口"));
		}
		conductors.forEach(o->o.start());
	}

}

解法一：使用Vector类来存放车票，注意Vector是安全对象，他的操作都具有安全性，那么Vector已经具有了安全性，我们只需要将上面错误案例中的ArrayList该问Vector就可以了吗？答案是当然不行，因为我们不能保证案例中的size方法和remove方法调用过程中间也都是安全的，即上例中的try catch包裹的部分，我们如果将其删除，程序也是没问题的，但是很显然该方法是不可取的，因为实际情况下，取票总是要时间的，所以我们需要加上synchronized关键字来保证其他过程的安全性。

public class T{
	
	static List<String> tickets=new Vector<String>();
	
	static {
		for(int i=1;i<=100;i++) {
			tickets.add(new String("编号"+i+"的车票"));
		}
	}
	
	void sale() {
		while(true) {
			synchronized (tickets) {
				if(tickets.size()==0) break;
				try {
					TimeUnit.MILLISECONDS.sleep(100);//睡眠100ms
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"销售了"+tickets.remove(0));
			}
		}
	}
	
	public static void main(String[] args){
		T t=new T();
		List<Thread> conductors=new ArrayList<Thread>();
		for(int i=1;i<=10;i++) {
			conductors.add(new Thread(t::sale,i+"号窗口"));
		}
		conductors.forEach(o->o.start());
	}

}

解法二：显然解法一也不少很友好，因为synchronized的使用，使得程序的效率并不是很高，接下来我们尝试用ConcurrentLinkedQueue来解决。ConcurrentLinkedQueue同样也是安全的，结合上例分析，为什么我们不加synchronized，下面代码的运行结果也是正确的那，因为即使线程1执行到了tickets.poll后，线程2在执行下面的if语句,相互之间也不会形成干扰。

public class T{
	
	static Queue<String> tickets=new ConcurrentLinkedQueue<String>();
	
	static {
		for(int i=1;i<=100;i++) {
			tickets.add(new String("编号"+i+"的车票"));
		}
	}
	
	void sale() {
		while(true) {
			String ticket=tickets.poll();
			if(ticket==null) break;		System.out.println(Thread.currentThread().getName()+"销售了"+ticket);
		}
	}
	
	
	public static void main(String[] args){
		T t=new T();
		List<Thread> conductors=new ArrayList<Thread>();
		for(int i=1;i<=10;i++) {
			conductors.add(new Thread(t::sale,i+"号窗口"));
		}
		conductors.forEach(o->o.start());
	}

}

12、几种并发Map的使用

12.1、ConcurrentHashMap

高并发安全容器，下面与传统的HashMap作对比。

public class T{
	
	ConcurrentHashMap<Object, Object> concurrentHashMap=new ConcurrentHashMap<>();
	HashMap<Object, Object> hashMap=new HashMap<>();
	final static int SIZE=10000;
	
	void testConcurrentHashMap(){
		List<Thread> threads=new ArrayList<>();
		long start=System.currentTimeMillis();
		for(int i=0;i<100;i++) {
			threads.add(new Thread(()-> {
				for(int j=0;j<SIZE;j++) {
					concurrentHashMap.put(new Object(), new Object());
				}
			}));
		}
		threads.forEach(o->o.start());
		threads.forEach(o->{
			try {
				o.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});
		long end=System.currentTimeMillis();
		System.out.println("Map大小:"+concurrentHashMap.size()+
				",使用ConcurrentHashMap所用时间"+(end-start));
	}
	
	void testHashMap(){
		List<Thread> threads=new ArrayList<>();
		long start=System.currentTimeMillis();
		for(int i=0;i<100;i++) {
			threads.add(new Thread(()-> {
				for(int j=0;j<SIZE;j++) {
					hashMap.put(new Object(), new Object());
				}
			}));
		}
		threads.forEach(o->o.start());
		threads.forEach(o->{
			try {
				o.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});
		long end=System.currentTimeMillis();
		System.out.println("Map大小:"+hashMap.size()+
				",使用HashMap所用时间"+(end-start));
	}
	
	public static void main(String[] args){
		T t=new T();
		t.testConcurrentHashMap();
		t.testHashMap();
	}

}

从运行结果可以看出，ConcurrentHashMap相比HashMap，多了并发安全性，而且效率也要高一点，从Concurrent（英文翻译：并存的）这个前缀也可以联想到。

12.2、ConcurrentSkipListMap

和ConcurrentHashMa相比，这个类在存放数据时，做了一个排序处理，也就是说这个map里面的元素都是有序的，相应他的效率要比ConcurrentHashMap要低很多。

public class T{
	
	Map<Integer, String> a=new ConcurrentSkipListMap<Integer, String>();
	Map<Integer, String> b=new ConcurrentSkipListMap<Integer, String>(new MyComparator());
	Random random=new Random();
	final static int MAX=1000;
	
	void testA() {
		List<Thread> threads=new Vector<Thread>();
		for(int i=0;i<10;i++) {
			threads.add(new Thread(()->{			
				for(int j=0;j<10;j++) {
					Integer key=random.nextInt(MAX);
					String value="data"+key;
					a.put(key, value);
				}					
			}));
		}
		threads.forEach(o->o.start());
		threads.forEach(o->{
			try {
				o.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});
		System.out.println("A的容器大小："+a.size());
		show(a);
	}
	
	synchronized void testB() {
		List<Thread> threads=new Vector<Thread>();
		for(int i=0;i<10;i++) {
			threads.add(new Thread(()->{
				for(int j=0;j<10;j++) {
					Integer key=random.nextInt(MAX);
					String value="data"+key;
					b.put(key, value);
				}
			}));
		}
		threads.forEach(o->o.start());
		threads.forEach(o->{
			try {
				o.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});
		System.out.println("B的容器大小："+b.size());
		show(b);
	}
	
	void show(Map map) {
		Iterator iterator=map.entrySet().iterator();
		while (iterator.hasNext()) {
			Map.Entry<Integer, String> entry=(Map.Entry)iterator.next();
			Integer key=entry.getKey();
			String value=entry.getValue();
			System.out.println("Key is "+key+",value is "+value);
		}
	}
	
	public static void main(String[] args){
		T t=new T();
		t.testA();
		System.out.println("-------------------------");
		t.testB();
	}

}

class MyComparator implements Comparator<Integer>{

	@Override
	public int compare(Integer o1, Integer o2) {
		return (o2-o1);
	}
	
}

ConcurrentSkipListMap类对象a是使用的默认的按照键的自然排序规则，对象b使用的是自定义排序器，从Concurrent可以猜到ConcurrentSkipListMap是一种线程安全的类，可是为什么输出的size不是100呢？因为这里，我们使用的是随机数，可能存在两个相同的key值，故size可能不是目标值100。

13、几种List的使用

13.1、ArrayList

public class T{
	
	static List<Integer> arrays=new ArrayList<Integer>();
	
	public static void main(String[] args){
		
		List<Thread> threads=new ArrayList<Thread>();
		Random random=new Random();
		for(int i=0;i<100;i++) {
			threads.add(new Thread(()->{
				for(int j=0;j<100;j++)
					arrays.add(random.nextInt(100));
			}));
		}
		threads.forEach(o->o.start());
		threads.forEach(o->{
			try {
				o.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});
		System.out.println("List大小:"+arrays.size());
	}

}

从运行结果可以看出size大小可能并不是100*100，因为ArrayList不是一个线程并发安全的List类型。

13.2、Vector

public class T{
	
	static List<Integer> arrays=new Vector<Integer>();
	
	public static void main(String[] args){
		
		List<Thread> threads=new ArrayList<Thread>();
		Random random=new Random();
		for(int i=0;i<100;i++) {
			threads.add(new Thread(()->{
				for(int j=0;j<100;j++)
					arrays.add(random.nextInt(100));
			}));
		}
		threads.forEach(o->o.start());
		threads.forEach(o->{
			try {
				o.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});
		System.out.println("List大小:"+arrays.size());
	}

}

运行结果为100*100，因为Vector是一个安全的List类型。

13.3、CopyOnWriteArrayList

public class T{
	
	static List<Integer> arrays=new CopyOnWriteArrayList<Integer>();
	
	public static void main(String[] args){
		
		List<Thread> threads=new ArrayList<Thread>();
		Random random=new Random();
		for(int i=0;i<100;i++) {
			threads.add(new Thread(()->{
				for(int j=0;j<100;j++)
					arrays.add(random.nextInt(100));
			}));
		}
		threads.forEach(o->o.start());
		threads.forEach(o->{
			try {
				o.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});
		System.out.println("List大小:"+arrays.size());
	}

}

CopyOnWriteArrayList是一个写时复制容器，它写的效率特别低，读的效率很高，上例将arrays改为CopyOnWriteArrayList类型，运行结果也一样是100*100，因为它是一个安全的类型，但其实上例这样改并不合适，因为CopyOnWriteArrayList比较适用于写少读多的应用场景。

13.4、Collections.synchronizedList

public class T{
	
	static List<Integer> arrays=new ArrayList<Integer>();
	
	static {
		arrays=Collections.synchronizedList(arrays);
	}
	
	public static void main(String[] args){
		
		List<Thread> threads=new ArrayList<Thread>();
		Random random=new Random();
		for(int i=0;i<100;i++) {
			threads.add(new Thread(()->{
				for(int j=0;j<100;j++)
					arrays.add(random.nextInt(100));
			}));
		}
		threads.forEach(o->o.start());
		threads.forEach(o->{
			try {
				o.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});
		System.out.println("List大小:"+arrays.size());
	}

}

Collections.synchronizedList方法可以将一个不安全的List类型转换为一个安全的List类型，经过该操作，上例运行结果一样是100*100。

14、几种Queue的使用

14.1、ConcurrentLinkedQueue

ConcurrentLinkedQueue是一个安全队列，关于ConcurrentLinkedQueue，上面其实已经有了一些简单的运用，下面我们来介绍一下它的常用方法，也可以说是Queue接口的相关实现类的通用方法。

public class T{
	
	static Queue<Integer> queue=new ConcurrentLinkedQueue<>();
	
	public static void main(String[] args){
		
		Random random=new Random();
		
		for(int i=0;i<10;i++){
			//offer是向队列中添加一个值，当队列已满时，add是抛出一个异常，offer是返回一个布尔值false
			queue.offer(random.nextInt(20));
		}
		System.out.println(queue);
		System.out.println("------------------------------------");
		//poll是从队首移出一个元素，并将该元素返回，当队列为空时，remove是抛出一个异常，poll是返回null
		System.out.println(queue.poll());
		System.out.println(queue);
		System.out.println("------------------------------------");
		//peek是从队首返回一个元素，不会移除，当队列为空时，element是抛出一个异常，peek则是返回null
		System.out.println(queue.peek());
		System.out.println(queue);
		
	}

}

14.2、LinkedBlockingQueue

基本使用如下，我们可以尝试用阻塞式队列解决之前的生产者消费者问题，具体实现自行思考。

public class T{
	
	static BlockingQueue<Integer> queue=new LinkedBlockingQueue<Integer>(10);//创建一个大小为10的阻塞式队列
	
	public static void main(String[] args){
		
		Random random=new Random();
		
		new Thread(()->{
			for(int i=0;i<100;i++) {
				try {
					//put方法是向队列中添加元素，当队列已满时，会等待添加，而不会放弃
					queue.put(random.nextInt(1000));
					TimeUnit.SECONDS.sleep(1);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).start();
		
		new Thread(()->{
			while(true) {
				try {
					//take方法是从队首移除一个元素，如果队列为空，会等待移除
					System.out.println("take from queue "+queue.take());
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).start();
			
	}
}

14.3、ArrayBlockingQueue

LinkedBlockQueue和ArrayBlockingQueue有以下几点不同：

ArrayBlockingQueue是一个基于数组的有界阻塞队列，而LinkedBlockQueue是一个基于链表的阻塞队列；
ArrayBlockingQueue的没有实现分离，即put和take用的是同一把锁，而LinkedBlockQueue的put和take则用的是两把不同的锁；
ArrayBlockingQueue在进行对象构造时必须指定队列的大小，而LinkedBlockQueue可以不指定队列的大小，默认是Integer.MAX_VALUE；
ArrayBlockingQueue在进行插入删除操作时，都是直接操作的，而LinkedBlockQueue都是先转换为一个Node节点再进行操作的，从第一点不同就能推理出，所以ArrayBlockingQueue的性能是优于LinkedBlockQueue的。

因为ArrayBlockingQueue的方法和LinkedBlockQueue的方法并无太大区别，在此就不做举例了，可以参考上面的LinkedBlockQueue或官方文档。

14.4、DelayQueue

DelayQueue是一个延时队列，即在指定的时间后，才能获取队列中的元素中的值。通过设计一个类实现Delayed接口，并重写getDelay和compareTo方法，其中getDelay是用于返回延时时间的，compareTo是返回一个对象与另一个对象的时间间隔的大小比较的结果的，这个设计的类对象将作为队列中的元素。

public class T{
	
	
	public static void main(String[] args) throws Exception{
		
		DelayQueue<Item> queue=new DelayQueue<Item>();
		Item item1=new Item("A", 4, TimeUnit.SECONDS);
		Item item2=new Item("B", 2, TimeUnit.SECONDS);
		Item item3=new Item("C", 6, TimeUnit.SECONDS);
		Long start=System.currentTimeMillis();
		queue.put(item1);
		queue.put(item2);
		queue.put(item3);
		for(int i=0;i<3;i++) {
			Item item=queue.take();		
			int get=(int)(System.currentTimeMillis()-start)/1000;
			System.out.println("Time in "+get+"s later,"+item+" was token from queue !");		
		}
	}

}

class Item implements Delayed{
	
	String value;
	private long time;
	
	public Item(String value,long time,TimeUnit unit) {
		this.value=value;
		this.time=System.currentTimeMillis()+unit.toMillis(time);
	}
	

	@Override
	public int compareTo(Delayed o) {
		Item another=(Item) o;
		long diff=this.time-another.time;
		return diff<=0?-1:1;
	}

	@Override
	public long getDelay(TimeUnit unit) {
		return time-System.currentTimeMillis();
	}
	
	@Override
	public String toString() {
		return value;
	}
	
}

14.5、LinkedTransferQueue

LinkedTransferQueue是一个无界阻塞队列，它和其他的Queue实现类相比，多了一个比较经典的transfer方法。下面来进行一下代码演示。

public class T{
	
	
	public static void main(String[] args) throws Exception{
		
		TransferQueue<Integer> queue=new LinkedTransferQueue<>();//无界阻塞队列
		
		new Thread(()->{
			try {
				System.out.println(queue.take());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}).start();
		
		queue.transfer(1);//将元素给消费者，等待取出，如果没有消费者，就会一直等待
		queue.tryTransfer(2, 3, TimeUnit.SECONDS);//3S钟之内如果元素还没有被消费者取出，就停止等待阻塞
		queue.put(3);//向队列中添加元素，不会形成等待
		
		System.out.println(queue);
		
	}

}

14.6、SynchronousQueue

SynchronousQueue是一个没有容量的无界非缓存同步队列。

public class T{
	
	
	public static void main(String[] args) throws Exception{
		
		BlockingQueue<Integer> queue=new SynchronousQueue<Integer>();//没有容量的阻塞队列
		
		new Thread(()->{
			try {
				System.out.println(queue.take());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}).start();
		
		queue.put(3);//插入元素，等待其他线程取出
		queue.put(4);//因为进行了两次put操作，只有一次take操作，所以这行的put操作会形成等待
		System.out.println("---------------------");
		
	}

}

15、线程池

前景引入：Executor是执行器的意思，它是Java提供的一个接口；ExecutorService是一个接口，提供了管理终止的方法，以及可为跟踪一个或多个异步任务执行状况而生成Future 的方法；Executors是可以用于创建各种类型的线程池。下面介绍一下它的简单使用。

public class T{
	
	
	public static void main(String[] args) throws Exception{
		
		new MyExecutor1().execute(()->{
			System.out.println(Thread.currentThread().getName()+" is running");
		});
		
		new MyExecutor2().execute(()->{
			System.out.println(Thread.currentThread().getName()+" is running");
		});
		
		System.out.println("main end");
	}

}

class MyExecutor1 implements Executor{//为一个任务创建一个新的线程并启动

	@Override
	public void execute(Runnable command) {
		new Thread(command).start();	
	}
	
}

class MyExecutor2 implements Executor{//在调用者的线程中,立即运行已提交的任务

	@Override
	public void execute(Runnable command) {
		command.run();
	}
	
}

15.1、newFixedThreadPool

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

public class T{
	
	
	public static void main(String[] args) throws Exception{
		
		ExecutorService service=Executors.newFixedThreadPool(5);//创建一个容量为5的有界线程池
		
		for(int i=0;i<6;i++) {//这里相当于给线程池中添加了6个线程
			service.execute(()->{
				 try {
	                    TimeUnit.SECONDS.sleep(1);
	                } catch (InterruptedException e) {
	                    e.printStackTrace();
	                }
                System.out.println(Thread.currentThread().getName());
			});
		}
			
		System.out.println(service);
		service.shutdown();//启动一次顺序关闭，执行以前提交的任务，但不接受新任务。
		//isTerminated方法，如果关闭后所有任务都已完成，则返回 true。
		System.out.println("任务都已完成："+service.isTerminated());
		System.out.println(service);
		TimeUnit.SECONDS.sleep(5);
		System.out.println(service);
	}

}

代码解读：以上对于service的输出，Running是表示线程池中的线程正在运行，Shutting down表示线程池已经关闭，pool size表示线程池的大小，active threads表示活跃的线程数，queue tasks表示排队等候的线程数，completed tasks表示完成的线程数，而对Thread.currentThread().getName()的输出可以看出，第一个线程和第六个线程，其实是同一个线程，并没有重新创建新的线程。

15.2、newCachedThreadPool

创建一个可缓存的线程池，如果线程池长度超过实际需要，空闲线程将会被回收，如果没有可回收的线程，则创建新的线程。回收的线程是60S未被使用的线程，从下面案例可以看出。

public class T{
	
	
	public static void main(String[] args) throws Exception{
		
		ExecutorService service=Executors.newCachedThreadPool();
		
		System.err.println(service);
		
		for(int i=0;i<4;i++) {//这里相当于给线程池中添加了4个线程
			service.execute(()->{
				 try {
	                    TimeUnit.MILLISECONDS.sleep(10);
	                } catch (InterruptedException e) {
	                    e.printStackTrace();
	                }
			});
		}
			
		System.out.println(service);
		TimeUnit.SECONDS.sleep(70);
		System.out.println(service);
	}

}

15.3、newSingleThreadExecutor

创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程，它的特点就是保证先进先出，即保证线程的顺序执行。

public class T{
	
	public static void main(String[] args){
		
		ExecutorService service= Executors.newSingleThreadExecutor();
        service.execute(()->{
        	try {
				TimeUnit.SECONDS.sleep(2);
				System.out.println("一号种子选手");
	            System.out.println(Thread.currentThread().getName());	     
	            System.out.println();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
        });
        service.execute(()->{
        	try {
				TimeUnit.SECONDS.sleep(1);
				System.out.println("二号种子选手");
	            System.out.println(Thread.currentThread().getName());	     
	            System.out.println();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
        });
        
	}

}

15.4、newScheduledThreadPool

创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行，ScheduledExecutorService相对于Timer更安全，功能更强大。

public class T{
	
	public static void main(String[] args){
		
		ScheduledExecutorService service= Executors.newScheduledThreadPool(4);
		
		//schedule是启动一个定时任务
        service.schedule(()->{
        	System.out.println("2S后执行");
        },2, TimeUnit.SECONDS);
         
        //scheduleAtFixedRate是启动一个周期任务，比如下面的就是启动一个0S开始，每2S执行一次的周期任务
        service.scheduleAtFixedRate(()->{
        	try {
				TimeUnit.SECONDS.sleep(1);
				System.out.println(Thread.currentThread().getName());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}    
        },0,2,TimeUnit.SECONDS);
        
        /*scheduleWithFixedDelay也是启动一个周期任务，但不同的是这个时间间隔表示的是一个任务完成另一个任务
         * 开始之间的间隔，比如下面的就是启动一个0S开始启动第一个任务，第一个任务完成后，2S后再执行第二个任务，
         * 即两个相邻任务之间的间隔为3S左右*/
        service.scheduleWithFixedDelay(()->{
        	try {
				TimeUnit.SECONDS.sleep(1);
				System.out.println(Thread.currentThread().getName());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}    
        },0,2,TimeUnit.SECONDS);
        
	}

}

15.5、newWorkStealingPool

newWorkStealingPool是JDK1.8之后才引入的，它适用于一些比较耗时的任务，比如文件下载。

public class T{
	
	public static void main(String[] args) throws Exception{
		
		ExecutorService service=Executors.newWorkStealingPool();
		//CountDownLatch latch=new CountDownLatch(10);
		System.out.println("start.........");
		for(int i=0;i<10;i++) {
			service.execute(()-> {
				try {
					TimeUnit.SECONDS.sleep(1);
					System.out.println(Thread.currentThread().getName());
					//latch.countDown();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}		
			});
		}
		//latch.await();
		System.out.println("end.........");
	}

}

从运行结果发现，线程名称并没有被打印，程序却显示已经结束，这是因为newWorkStealingPool产生的是一个精灵线程（后台线程、守护线程），不对其进行阻塞，是看不到输出的，将上例中的注释删除，即可发现输出的线程名称。

15.6、ForkJoinPool

ForkJoinPool是JDK1.8引入的线程池，核心思想就是将一个大的任务进行拆分成若干个小的任务（fork），然后再将这些小的任务结果进行汇总（join）。使用了工作窃取算法（Work stealing）。下面我们利用ForkJoinPool来设计一个求和算法，即将其拆成一个个区间，进行拆分求和，分治算法。

public class T{
	
	static int[] nums=new int[1000000];
    static Random r=new Random();   
    
    static {
    	for(int i=0;i<nums.length;i++)
    		nums[i]=r.nextInt(100);
    	System.out.println(Arrays.stream(nums).sum());//输出nums数组的和
    }
    
    /*使用ForkJoinPool首先得创建一个ForkJoin任务，
     * 下面的是内部类继承自RecursiveTask，用于有返回值的任务
     * 返回值是Long，当不需要返回值是，可以写一个内部类继承自RecursiveAction*/
    static class Task extends RecursiveTask<Long>{
    	
    	int start,end;
    	final static int MAX=10000;
    	
    	public Task(int start,int end) {
    		this.start=start;
    		this.end=end;
    	}

    	@Override
    	protected Long compute() {
    		if(end-start<=MAX) {
    			long sum=0L;
    			for(int i=start;i<end;i++)
    				sum+=nums[i];
    			return sum;
    		}
    		int middle=start+(end-start)/2;//区间中间值的位置
    		Task task1=new Task(start, middle);
    		Task task2=new Task(middle, end);
    		task1.fork();
    		task2.fork();
    		return task1.join()+task2.join();//其实这里使用了递归算法
    	}
    	
    }
	
	public static void main(String[] args) throws Exception{
		
		ForkJoinPool forkJoinPool=new ForkJoinPool();
		Task task=new Task(0,nums.length);
		forkJoinPool.execute(task);
		long result=task.join();
		System.out.println(result);
		
	}

}

15.7、parallelStream

既然讲到了ForkJoinPool，那我们就不得不认识一下parallelStream了，它是一个并行执行的流，将每一段任务分而治之，大任务切成小任务。

public class T{
	
	static List<Integer> arrays =new ArrayList<Integer>();
	
    static {
    	for(int i=0;i<10;i++)
    		arrays.add(i);
    }
    
	public static void main(String[] args){
		
		System.out.println(arrays);
		
		arrays.parallelStream().forEach(x->print(x));
		
		System.out.println();
		
		arrays.parallelStream().forEachOrdered(x->print(x));
		
	}
	
	static void print(Integer x) {
		System.out.print(x+"\t");
	}

}

因为是并行处理，所以foreach输出的结果可能是无序的，如果想要有序，可以使用foreachOrder。

16、FutureTask

可取消的异步计算。利用开始和取消计算的方法、查询计算是否完成的方法和获取计算结果的方法，此类提供了对 Future 的基本实现。仅在计算完成时才能获取结果；如果计算尚未完成，则阻塞 get 方法。一旦计算完成，就不能再重新开始或取消计算。

public class T{
	
	static List<Integer> arrays =new ArrayList<Integer>();
	
    static {
    	for(int i=0;i<1000000;i++)
    		arrays.add(i);
    }
    
    static class Task implements Callable<Long>{

		@Override
		public Long call() throws Exception {
			Long sum=0L;
			System.out.println("FutureTask is running");
			for(int i=0;i<arrays.size();i++)
				sum+=arrays.get(i);
			System.out.println("FutureTask is end");
			return sum;
		} 	
    	
    }
    
	public static void main(String[] args) throws Exception{
		
		System.out.println("Main start");
		FutureTask<Long> task=new FutureTask<>(new Task());
		new Thread(task).start();
		System.out.println(task.get());
		System.out.println("Main is end");
	}
	
}

你可能感兴趣的:(Java)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
JAVA·一个简单的登录窗口 MortalTom java 开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
00. 这里整理了最全的爬虫框架（Java + Python）有一只柴犬爬虫系列爬虫 java python
目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
切换淘宝最新npm镜像源是 hai40587 npm 前端 node.js
切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java 开发语言
文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式 java
文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
ztree异步加载 3213213333332132 JavaScript Ajax json Web ztree
相信新手用ztree的时候,对异步加载会有些困惑，我开始的时候也是看了API花了些时间才搞定了异步加载，在这里分享给大家。我后台代码生成的是json格式的数据，数据大家按各自的需求生成，这里只给出前端的代码。设置setting，这里只关注async属性的配置 var setting = { //异步加载配置
thirft rpc 具体调用流程 BlueSkator 中间件 rpc thrift
Thrift调用过程中，Thrift客户端和服务器之间主要用到传输层类、协议层类和处理类三个主要的核心类，这三个类的相互协作共同完成rpc的整个调用过程。在调用过程中将按照以下顺序进行协同工作：（1）将客户端程序调用的函数名和参数传递给协议层（TProtocol），协议
异或运算推导, 交换数据 dcj3sjt126com PHP 异或 ^
/* * 5 0101 * 9 1010 * * 5 ^ 5 * 0101 * 0101 * ----- * 0000 * 得出第一个规律: 相同的数进行异或, 结果是0 * * 9 ^ 5 ^ 6 * 1010 * 0101 * ---- * 1111 * * 1111 * 0110 * ---- * 1001
事件源对象周华华 JavaScript
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
MySql配置及相关命令 g21121 mysql
MySQL安装完毕后我们需要对它进行一些设置及性能优化，主要包括字符集设置，启动设置，连接优化，表优化，分区优化等等。一修改MySQL密码及用户
[简单]poi删除excel 2007超链接 53873039oycg Excel
采用解析sheet.xml方式删除超链接，缺点是要打开文件2次,代码如下: public void removeExcel2007AllHyperLink(String filePath) throws Exception { OPCPackage ocPkg = OPCPac
Struts2添加 open flash chart 云端月影
准备以下开源项目： 1. Struts 2.1.6 2. Open Flash Chart 2 Version 2 Lug Wyrm Charmer (28th, July 2009) 3. jofc2，这东西不知道是没做好还是什么意思，好像和ofc2不怎么匹配，最好下源码，有什么问题直接改。 4. log4j 用eclipse新建动态网站，取名OFC2Demo，将Struts2 l
spring包详解 aijuans spring
下载的spring包中文件及各种包众多，在项目中往往只有部分是我们必须的，如果不清楚什么时候需要什么包的话，看看下面就知道了。 aspectj目录下是在Spring框架下使用aspectj的源代码和测试程序文件。Aspectj是java最早的提供AOP的应用框架。 dist 目录下是Spring 的发布包，关于发布包下面会详细进行说明。 docs&nb
网站推广之seo概念 antonyup_2006 算法 Web 应用服务器搜索引擎 Google
持续开发一年多的b2c网站终于在08年10月23日上线了。作为开发人员的我在修改bug的同时，准备了解下网站的推广分析策略。所谓网站推广，目的在于让尽可能多的潜在用户了解并访问网站，通过网站获得有关产品和服务等信息，为最终形成购买决策提供支持。网站推广策略有很多，seo，email，adv
单例模式,sql注入,序列百合不是茶单例模式序列 sql注入预编译
序列在前面写过有关的博客,也有过总结,但是今天在做一个JDBC操作数据库的相关内容时需要使用序列创建一个自增长的字段居然不会了,所以将序列写在本篇的前面 1,序列是一个保存数据连续的增长的一种方式; 序列的创建; CREATE SEQUENCE seq_pro 2 INCREMENT BY 1 -- 每次加几个 3
Mockito单元测试实例 bijian1013 单元测试 mockito
Mockito单元测试实例： public class SettingServiceTest { private List<PersonDTO> personList = new ArrayList<PersonDTO>(); @InjectMocks private SettingPojoService settin
精通Oracle10编程SQL(9)使用游标 bijian1013 oracle 数据库 plsql
/* *使用游标 */ --显示游标 --在显式游标中使用FETCH...INTO语句 DECLARE CURSOR emp_cursor is select ename,sal from emp where deptno=1; v_ename emp.ename%TYPE; v_sal emp.sal%TYPE; begin ope
【Java语言】动态代理 bit1129 java语言
JDK接口动态代理 JDK自带的动态代理通过动态的根据接口生成字节码(实现接口的一个具体类)的方式，为接口的实现类提供代理。被代理的对象和代理对象通过InvocationHandler建立关联 package com.tom; import com.tom.model.User; import com.tom.service.IUserService;
Java通信之URL通信基础白糖_ java jdk webservice 网络协议 ITeye
java对网络通信以及提供了比较全面的jdk支持，java.net包能让程序员直接在程序中实现网络通信。在技术日新月异的现在，我们能通过很多方式实现数据通信，比如webservice、url通信、socket通信等等，今天简单介绍下URL通信。学习准备：建议首先学习java的IO基础知识 URL是统一资源定位器的简写，URL可以访问Internet和www，可以通过url
博弈Java讲义 - Java线程同步 (1) boyitech java 多线程同步锁
在并发编程中经常会碰到多个执行线程共享资源的问题。例如多个线程同时读写文件，共用数据库连接，全局的计数器等。如果不处理好多线程之间的同步问题很容易引起状态不一致或者其他的错误。同步不仅可以阻止一个线程看到对象处于不一致的状态，它还可以保证进入同步方法或者块的每个线程，都看到由同一锁保护的之前所有的修改结果。处理同步的关键就是要正确的识别临界条件（cri
java-给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。 bylijinnan java
public class DeleteExtraSpace { /** * 题目：给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。 * 方法1.用已有的String类的trim和replaceAll方法 * 方法2.全部用正则表达式，这个我不熟 * 方法3.“重新发明轮子”，从头遍历一次 */ public static v
An error has occurred.See the log file错误解决！ Kai_Ge MyEclipse
今天早上打开MyEclipse时，自动关闭！弹出An error has occurred.See the log file错误提示！很郁闷昨天启动和关闭还好着！！！打开几次依然报此错误，确定不是眼花了！打开日志文件！找到当日错误文件内容： --------------------------------------------------------------------------
[矿业与工业]修建一个空间矿床开采站要多少钱? comsci
地球上的钛金属矿藏已经接近枯竭........... 我们在冥王星的一颗卫星上面发现一些具有开采价值的矿床..... 那么,现在要编制一个预算,提交给财政部门..
解析Google Map Routes dai_lm google api
为了获得从A点到B点的路劲，经常会使用Google提供的API，例如 [url] http://maps.googleapis.com/maps/api/directions/json?origin=40.7144,-74.0060&destination=47.6063,-122.3204&sensor=false [/url] 从返回的结果上，大致可以了解应该怎么走，但
SQL还有多少“理所应当”？ datamachine sql
转贴存档，原帖地址：http://blog.chinaunix.net/uid-29242841-id-3968998.html、http://blog.chinaunix.net/uid-29242841-id-3971046.html！ ------------------------------------华丽的分割线--------------------------------
Yii使用Ajax验证时，如何设置某些字段不需要验证 dcj3sjt126com Ajax yii
经常像你注册页面,你可能非常希望只需要Ajax去验证用户名和Email,而不需要使用Ajax再去验证密码,默认如果你使用Yii 内置的ajax验证Form,例如: $form=$this->beginWidget('CActiveForm', array( 'id'=>'usuario-form',&
使用git同步网站代码 dcj3sjt126com crontab git
转自:http://ued.ctrip.com/blog/?p=3646?tn=gongxinjun.com 管理一网站，最开始使用的虚拟空间，采用提供商支持的ftp上传网站文件，后换用vps，vps可以自己搭建ftp的，但是懒得搞，直接使用scp传输文件到服务器，现在需要更新文件到服务器，使用scp真的很烦。发现本人就职的公司，采用的git+rsync的方式来管理、同步代码，遂
sql基本操作蕃薯耀 sql sql基本操作 sql常用操作
sql基本操作 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月1日 17:30:33 星期一 &
Spring4+Hibernate4+Atomikos3.3多数据源事务管理 hanqunfeng Hibernate4
Spring3+后不再对JTOM提供支持，所以可以改用Atomikos管理多数据源事务。Spring2.5+Hibernate3+JTOM参考：http://hanqunfeng.iteye.com/blog/1554251Atomikos官网网站：http://www.atomikos.com/ 一.pom.xml <dependency> <
jquery中两个值得注意的方法one()和trigger()方法 jackyrong trigger
在jquery中，有两个值得注意但容易忽视的方法，分别是one()方法和trigger()方法,这是从国内作者<<jquery权威指南》一书中看到不错的介绍 1） one方法 one方法的功能是让所选定的元素绑定一个仅触发一次的处理函数，格式为 one(type,${data},fn) &nb
拿工资不仅仅是让你写代码的 lampcy 工作面试咨询
这是我对团队每个新进员工说的第一件事情。这句话的意思是，我并不关心你是如何快速完成任务的，哪怕代码很差，只要它像救生艇通气门一样管用就行。这句话也是我最喜欢的座右铭之一。这个说法其实很合理：我们的工作是思考客户提出的问题，然后制定解决方案。思考第一，代码第二，公司请我们的最终目的不是写代码，而是想出解决方案。话粗理不粗。付你薪水不是让你来思考的，也不是让你来写代码的，你的目的是交付产品
架构师之对象操作----------对象的效率复制和判断是否全为空 nannan408 架构师
1.前言。如题。 2.代码。 (1)对象的复制，比spring的beanCopier在大并发下效率要高，利用net.sf.cglib.beans.BeanCopier Src src=new Src(); BeanCopier beanCopier = BeanCopier.create(Src.class, Des.class, false);
ajax 被缓存的解决方案 Rainbow702 JavaScript jquery Ajax cache 缓存
使用jquery的ajax来发送请求进行局部刷新画面，各位可能都做过。今天碰到一个奇怪的现象，就是，同一个ajax请求，在chrome中，不论发送多少次，都可以发送至服务器端，而不会被缓存。但是，换成在IE下的时候，发现，同一个ajax请求，会发生被缓存的情况，只有第一次才会被发送至服务器端，之后的不会再被发送。郁闷。解决方法如下： ① 直接使用 JQuery提供的 “cache”参数，
修改date.toLocaleString()的警告 tntxia String
我们在写程序的时候，经常要查看时间，所以我们经常会用到date.toLocaleString()，但是date.toLocaleString()是一个过时的API，代替的方法如下： package com.tntxia.htmlmaker.util; import java.text.SimpleDateFormat; import java.util.
项目完成后的小总结 xiaomiya js 总结项目
项目完成了，突然想做个总结但是有点无从下手了。做之前对于客户端给的接口很模式。然而定义好了格式要求就如此的愉快了。先说说项目主要实现的功能吧 1，按键精灵 2，获取行情数据 3，各种input输入条件判断 4，发送数据（有json格式和string格式） 5，获取预警条件列表和预警结果列表， 6，排序， 7，预警结果分页获取 8，导出文件（excel，text等） 9，修