Wang_AI
Wang_AI

JavaSE---多线程、面向对象设计思想、设计模式


7.  多线程

7.1 多线程的概述

7.1.1 线程的概念

    什么是线程呢？想要知道线程，就必须先知道进程。进程就是正在运行的程序，是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。

    线程是进程中的单个顺序控制流，是一条执行路径。一个进程如果只有一条执行路径，则称为单线程程序；一个进程如果有多条执行路径，则称为多线程程序。

    一个进程可以有一到多个线程，而一个线程只能属于一个进程。

思考题1：jvm虚拟机的启动是单线程的还是多线程？

    多线程。因为JVM启动时相当于启动了一个进程，然后这个进程会创建一个主线程和垃圾回收线程以及其他的一些线程，主线程会调用main方法，垃圾回收线程会用来回收一些垃圾。

思考题2：并行和并发的区别

    并行是逻辑上同时发生，指在某一个时间内同时运行多个程序。

    并发是物理上同时发生，指在某一个时间点同时运行多个程序。

7.1.2 多线程的利弊

    利处：解决了多部分代码同时运行的问题。

    弊端：线程太多，会导致效率的降低。

7.2 多线程的创建

    由于线程是依赖进程而存在的，所以我们应该先创建一个进程出来，而进程是由系统创建的，所以我们应该去调用系统功能创建一个进程。Java是不能直接调用系统功能的，所以，我们没有办法直接实现多线程程序。但是Java可以去调用C/C++写好的程序来实现多线程程序。由C/C++去调用系统功能创建进程，然后由Java去调用这样的东西，然后提供一些类或者接口供我们使用，这样就可以实现多线程了。创建线程有两种方法：一种是继承Thread类；另一种是通过实现Runnable接口。

7.2.1 继承Thread类

    1）定义一个类并继承Thread。

    2）重写Thread类的 run()方法。 

    3）建立自定义类的一个对象（此时一个线程也被建立）。 

    4）调用线程的start()方法。 

    示例：

public class MyThreadDemo {
	public static void main(String[] args) {
		//创建两个线程对象
		MyThread my1 = new MyThread();
		MyThread my2 = new MyThread();
		
		my1.start();
		my2.start();
	}
}

class MyThread extends Thread {
	@Override
	public void run() {
		// 自己写代码
		// System.out.println("好好学习，天天向上");
		// 一般来说，被线程执行的代码肯定是比较耗时的，所以我们用循环改进
		for(int x = 0;x<100;x++){
			System.out.println(x);
		}
	}
}

    思考1：为什么要重写run()方法呢？

    创建一个线程类，run()方法里面包含的是需要被线程执行的代码。

    思考2：run()和start()的区别?

    run():仅仅是封装被线程执行的代码，直接调用是普通方法

    start():首先启动了线程，然后再由jvm去调用该线程的run()方法。

7.2.2 实现Runnable接口

    1）定义类实现Runnable接口

    2）覆盖Runnable接口中的run()方法。

    3）通过Thread类建立线程对象。 

    4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。 

    5）调用Thread类的star()t方法开启线程

    示例：

public class MyRunnableDemo {
	public static void main(String[] args) {
		// 创建MyRunnable类的对象
		MyRunnable my = new MyRunnable();

		// Thread(Runnable target, String name)
		Thread t1 = new Thread(my);
		Thread t2 = new Thread(my);

		t1.start();
		t2.start();
	}
}

class MyRunnable implements Runnable {

	@Override
	public void run() {
		for (int x = 0; x < 100; x++) {
			System.out.println(x);
		}
	}

}


7.3 多线程的设置和控制

7.3.1 获取和设置线程对象名

    获取：

    public final String getName():获取线程的名称。

    针对不是Thread类的子类中获取线程对象名的方法

    public static Thread currentThread():返回当前正在执行的线程对象

    Thread.currentThread().getName()

    设置：

    1）public final void setName(String name):设置线程的名称

    2）通过构造方法

public class MyThreadDemo {
	public static void main(String[] args) {
		// 创建线程对象
		// 无参构造+setXxx()
		MyThread my1 = new MyThread();
		MyThread my2 = new MyThread();

		// 调用set方法设置名称
		my1.setName("林青霞");
		my2.setName("东方不败");

		my1.start();
		my2.start();

		// 带参构造方法给线程起名字
		MyThread my3 = new MyThread("李亚鹏");
		MyThread my4 = new MyThread("令狐冲");

		my3.start();
		my4.start();

		// 我要获取main方法所在的线程对象的名称，该怎么办呢?
		// 遇到这种情况,Thread类提供了一个很好玩的方法:
		// public static Thread currentThread():返回当前正在执行的线程对象
		System.out.println(Thread.currentThread().getName());
	}
}

class MyThread extends Thread {
	public MyThread() {
	}
	// 通过构造方法设置对象名
	public MyThread(String name) {
		super(name);
	}

	@Override
	public void run() {
		for (int x = 0; x < 100; x++) {
			// 获取对象名
			System.out.println(getName() + ":" + x);
		}
	}
}

7.3.2 获取和设置线程优先级

    假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到 CPU时间片，也就是使用权，才可以执行指令。那么Java是如何对线程进行调用的呢？

    线程有两种调度模型：

    分时调度模型    所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片

    抢占式调度模型    优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些。

    Java使用的是抢占式调度模型。

    获取线程对象的优先级：

    public final int getPriority():返回线程对象的优先级

    设置线程对象的优先级

    public final void setPriority(int newPriority)：更改线程的优先级。线程默认优先级是5(NORM_PRIORITY)，可设置线程优先级的范围是：1(MIN_PRIORITY)-10(MAX_PRIORITY)。 

public class ThreadPriorityDemo {
	public static void main(String[] args) {
		ThreadPriority tp1 = new ThreadPriority();
		ThreadPriority tp2 = new ThreadPriority();
		ThreadPriority tp3 = new ThreadPriority();

		tp1.setName("线程1");
		tp2.setName("线程2");
		tp3.setName("线程3");

		//设置线程优先级
		tp1.setPriority(Thread.MAX_PRIORITY);
		tp2.setPriority(Thread.MIN_PRIORITY);
		tp3.setPriority(Thread.NORM_PRIORITY);
		
		 tp1.start();
		 tp2.start();
		 tp3.start();
		
	}
}

class ThreadPriority extends Thread{
	@Override
	public void run() {
		for(int x =0;x<100;x++){
			System.out.println(getName()+":"+x);
		}
	}
}

    运行后发现基本上先是线程1线执行的，最后是线程3执行的。

7.3.3 线程休眠(sleep)

    public static void sleep(long millis)

    示例：

import java.util.Date;

public class ThreadSleepDemo {
	public static void main(String[] args) {
		ThreadSleep ts1 = new ThreadSleep();
		ThreadSleep ts2 = new ThreadSleep();
		ThreadSleep ts3 = new ThreadSleep();

		ts1.setName("线程1");
		ts2.setName("线程2");

		ts1.start();
		ts2.start();
	}
}

class ThreadSleep extends Thread{
	@Override
	public void run() {
		for (int x = 0; x < 2; x++) {
			System.out.println(getName() + ":" + x+",日期："+new Date());
			//睡眠
			//休眠1秒钟
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

    运行结果：

JavaSE---多线程、面向对象设计思想、设计模式_第1张图片

7.3.4 线程加入(join)

    public final void join():等待该线程终止。必须用在该线程启动后。 

    示例：

public class ThreadJoinDemo {
	public static void main(String[] args) {
		ThreadJoin tj1 = new ThreadJoin();
		ThreadJoin tj2 = new ThreadJoin();
		ThreadJoin tj3 = new ThreadJoin();
		
		tj1.setName("李渊");
		tj2.setName("李世民");
		tj3.setName("李元霸");
		
		tj1.start();
		try {
			tj1.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		tj2.start();
		tj3.start();
	}
}

class ThreadJoin extends Thread {
	@Override
	public void run() {
		for (int x = 0; x < 100; x++) {
			System.out.println(getName() + ":" + x);
		}
	}
}

    运行后发现在线程“李渊”运行完成后才是线程“李世民”和“李元霸”在争夺CPU执行权

7.3.5 线程礼让(yield)

    public static void yield():将当前线程变为可执行状态，然后与其他线程再次抢夺CPU的执行权。 可以使让多个线程的执行更和谐，但是不能靠它来保证一人一次。

    示例：

public class ThreadYieldDemo {
	public static void main(String[] args) {
		ThreadYield ty1 = new ThreadYield();
		ThreadYield ty2 = new ThreadYield();
		
		ty1.setName("令狐冲");
		ty2.setName("任盈盈");
		
		ty1.start();
		ty2.start();
	}
}

class ThreadYield extends Thread {
	@Override
	public void run() {
		for (int x = 0; x < 100; x++) {
			System.out.println(getName() + ":" + x);
			Thread.yield();
		}
	}
}

    运行结果：

JavaSE---多线程、面向对象设计思想、设计模式_第2张图片

7.3.6 后台线程(setDaemon)

    public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。 

    示例：

public class ThreadDaemonDemo {
	public static void main(String[] args) {
		ThreadDaemon td1 = new ThreadDaemon();
		ThreadDaemon td2 = new ThreadDaemon();

		td1.setName("关羽");
		td2.setName("张飞");

		// 设置收获线程
		td1.setDaemon(true);
		td2.setDaemon(true);

		td1.start();
		td2.start();

		Thread.currentThread().setName("刘备");
		for (int x = 0; x < 5; x++) {
			System.out.println(Thread.currentThread().getName() + ":" + x);
		}
	}
}

class ThreadDaemon extends Thread{
	@Override
	public void run() {
		for (int x = 0; x < 100; x++) {
			System.out.println(getName() + ":" + x);
		}
	}
}

    运行结果:

JavaSE---多线程、面向对象设计思想、设计模式_第3张图片

    由于“关羽”线程和“张飞”线程被设置为后台线程，所以在其他线程运行完成后，这两个后台线程也会停止运行。

7.3.7 中断线程(stop/interrupt)

    public final void stop():让线程停止，过时了，但是现在还可以使用。

     public void interrupt():中断线程。 把线程的状态终止，并抛出一个InterruptedException。

import java.util.Date;

public class ThreadStopDemo {
	public static void main(String[] args) {
		ThreadStop ts = new ThreadStop();
		ts.start();

		// 你超过三秒不醒过来，我就干死你
		try {
			Thread.sleep(3000);
			// ts.stop();
			ts.interrupt();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class ThreadStop extends Thread {
	@Override
	public void run() {
		System.out.println("开始执行：" + new Date());

		// 我要休息10秒钟，亲，不要打扰我哦
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			// e.printStackTrace();
			System.out.println("线程被终止了");
		}

		System.out.println("结束执行：" + new Date());
	}
}

    运行结果：

JavaSE---多线程、面向对象设计思想、设计模式_第4张图片

7.3.8 线程组

    线程组： 把多个线程组合到一起。它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。

public class ThreadGroupDemo {
	public static void main(String[] args) {
		// 创建两个线程并查看所属默认线程组
		method1();

		System.out.println("-----------");
		// 修改线程所在组
		// 创建一个线程组
		// 创建其他线程的时候，把其他线程的组指定为我们自己新建线程组
		method2();
	}

	private static void method2() {
		// ThreaadGroup(String name)
		ThreadGroup tg = new ThreadGroup("这是一个新的组");

		MyRunnable my = new MyRunnable();
		// Thread(ThreadGroup group, Runnable target, String name)
		Thread t1 = new Thread(tg, my, "林青霞");
		Thread t2 = new Thread(tg, my, "东方不败");

		System.out.println(t1.getThreadGroup().getName());
		System.out.println(t2.getThreadGroup().getName());

		// 通过组名称设置后台线程，表示该组的线程都是后台线程
		tg.setDaemon(true);
	}

	private static void method1() {
		MyRunnable my = new MyRunnable();
		Thread t1 = new Thread(my, "林青霞");
		Thread t2 = new Thread(my, "东方不败");
		// 我不知道他们属于那个线程组,我想知道，怎么办
		// 线程类里面的方法：public final ThreadGroup getThreadGroup()
		ThreadGroup tg1 = t1.getThreadGroup();
		ThreadGroup tg2 = t2.getThreadGroup();
		// 线程组里面的方法：public final String getName()
		String name1 = tg1.getName();
		String name2 = tg2.getName();
		System.out.println(name1);
		System.out.println(name2);
		// 通过结果我们知道了：线程默认情况下属于main线程组
		// 通过下面的测试，你应该能够看到，默任情况下，所有的线程都属于同一个组
		System.out.println(Thread.currentThread().getThreadGroup().getName());
	}
}
class MyRunnable implements Runnable{
	@Override
	public void run() {
		for(int x = 0;x<100;x++){
			System.out.println(Thread.currentThread().getName()+":"+x);
		}
	}
}

    运行结果：

JavaSE---多线程、面向对象设计思想、设计模式_第5张图片

7.4 多线程安全问题

    例：模拟电影院有3个窗口卖票案例

public class SellTicketDemo {
	public static void main(String[] args) {
		// 创建3个线程对象
		SellTicket st1 = new SellTicket();
		SellTicket st2 = new SellTicket();
		SellTicket st3 = new SellTicket();

		// 设置线程名称
		st1.setName("窗口1");
		st2.setName("窗口2");
		st3.setName("窗口3");

		// 启动线程
		st1.start();
		st2.start();
		st3.start();
	}
}
class SellTicket extends Thread {

	// 定义100张票
	// private int tickets = 100;
	// 为了让多个线程对象共享这100张票，我们其实应该用静态修饰
	private static int tickets = 100;

	@Override
	public void run() {
		// 定义100张票
		// 每个线程进来都会走这里，这样的话，每个线程对象相当于买的是自己的那100张票，这不合理，所以应该定义到外面
		// int tickets = 100;

		// 是为了模拟一直有票
		while (tickets > 0) {
			System.out.println(getName() + "正在出售第" + (tickets--) + "张票");
		}
	}
}

    由于100张票是共享资源，上面用SellTicket类继承Thread类来实现3个窗口卖票要建立3个SellTicket类对象，不太符合现实。通过继承Runnable接口来做这种共享资源的示例会方便很多。代码如下： 

public class SellTicketDemo {
	public static void main(String[] args) {
		//创建资源对象
		SellTicket st = new SellTicket();
		
		//创建3个线程对象
		Thread t1 = new Thread(st,"窗口1");
		Thread t2 = new Thread(st,"窗口2");
		Thread t3 = new Thread(st,"窗口3");
		
		//启动线程
		t1.start();
		t2.start();
		t3.start();
	}
}
class SellTicket implements Runnable {
	//定义100张票
	private int tickets = 100;
	@Override
	public void run() {
		while(tickets>0){
			System.out.println(Thread.currentThread().getName()+"正在出第"+(tickets--)+"票");
		}
	}

}

    在现实生活中，售票时网络不能实时传输，总会存在一点点的延迟，所以在出售一张票以后，需要一点时间的延续，假定每次卖一张票后延时100ms。

public class SellTicketDemo {
	public static void main(String[] args) {
		// 创建资源对象
		SellTicket st = new SellTicket();

		// 创建三个线程对象
		Thread t1 = new Thread(st, "窗口1");
		Thread t2 = new Thread(st, "窗口2");
		Thread t3 = new Thread(st, "窗口3");

		// 启动线程
		t1.start();
		t2.start();
		t3.start();
	}
}
class SellTicket implements Runnable {
	// 定义100张票
	private int tickets = 100;

	@Override
	public void run() {
		while (true) {
			// t1,t2,t3三个线程
			// 这一次的tickets = 1;
			if (tickets > 0) {
				// 为了模拟更真实的场景，我们稍作休息
				try {
					Thread.sleep(100); //t1进来了并休息，t2进来了并休息，t3进来了并休息，
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

				System.out.println(Thread.currentThread().getName() + "正在出售第"
						+ (tickets--) + "张票");
				//窗口1正在出售第1张票,tickets=0
				//窗口2正在出售第0张票,tickets=-1
				//窗口3正在出售第-1张票,tickets=-2
			}
		}
	}
}

    运行结果：

JavaSE---多线程、面向对象设计思想、设计模式_第6张图片

    发现打印出0、-1等错票，说明多线程存在安全问题。

7.4.1 出错原因和出错位置

    1. 出错原因：

    当多条语句在操作多个线程共享数据时，如果一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，就会导致共享数据出错。

    2. 出错位置：

    1）明确哪些代码是多线程运行代码。 
    2）明确共享数据。 
    3）明确多线程运行代码中哪些语句是操作共享数据的。

7.2.2 解决办法

    把多条线程操作共享数据的代码给包成一个整体，让某个线程在执行的时候，别人不能来执行。Java提供了对象锁机制来解决

    1. synchronized关键字

    1）synchronized代码块

    格式：

    synchronized(对象){

        需要同步的代码

    }

    使用synchronized的前提：必须是两个或两个以上的线程使用同一个锁。

    如果加了synchronized后仍然出现安全问题，就应该考虑上面的前提是否满足。

public class SellTicketDemo {
	public static void main(String[] args) {
		// 创建资源对象
		SellTicket st = new SellTicket();

		// 创建三个线程对象
		Thread t1 = new Thread(st, "窗口1");
		Thread t2 = new Thread(st, "窗口2");
		Thread t3 = new Thread(st, "窗口3");

		// 启动线程
		t1.start();
		t2.start();
		t3.start();
	}
}
class SellTicket implements Runnable {
	// 定义100张票
	private int tickets = 100;
	//创建锁对象
	private Object obj = new Object();
	
	@Override
	public void run() {
		while (true) {
			synchronized (obj) {
				if (tickets > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()
							+ "正在出售第" + (tickets--) + "张票");
				}
			}
		}
	}
}

    运行结果：

JavaSE---多线程、面向对象设计思想、设计模式_第7张图片

    2）synchronized方法

    格式：synchronized void method(){}

public class SellTicketDemo {
	public static void main(String[] args) {
		// 创建资源对象
		SellTicket st = new SellTicket();

		// 创建三个线程对象
		Thread t1 = new Thread(st, "窗口1");
		Thread t2 = new Thread(st, "窗口2");
		Thread t3 = new Thread(st, "窗口3");

		// 启动线程
		t1.start();
		t2.start();
		t3.start();
	}
}
class SellTicket implements Runnable {

	// 定义100张票
	private static int tickets = 100;

	private int x = 0;
	
	@Override
	public void run() {
		while (true) {
			if(x%2==0){
				synchronized (this) {
					if (tickets > 0) {
						try {
							Thread.sleep(100);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName()
								+ "正在出售第" + (tickets--) + "张票 ");
					}
				}
			}else {
				sellTicket();
				
			}
			x++;
		}
	}
	private synchronized void sellTicket() {
		if (tickets > 0) {
		try {
				Thread.sleep(100);
		} catch (InterruptedException e) {
				e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()
					+ "正在出售第" + (tickets--) + "张票 ");
		}
	}
}

    运行结果：

JavaSE---多线程、面向对象设计思想、设计模式_第8张图片

    由此可以看出synchronized方法的所对象是this。如果synchronized方法再加上static修饰后，锁对象是什么呢？由于静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象，所以该对象就成了静态同步方法的锁对象。

    2. Lock锁

    为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的接口Lock。Lock中的lock()方法用来加锁，unlock(()方法用来解锁。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
 * 虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，
 * 为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock。
 * 
 * Lock：
 * 		void lock()： 获取锁。
 * 		void unlock():释放锁。  
 * ReentrantLock是Lock的实现类.
 */
public class SellTicketDemo {
	public static void main(String[] args) {
		// 创建资源对象
		SellTicket st = new SellTicket();

		// 创建3个线程
		Thread t1 = new Thread(st, "窗口1");
		Thread t2 = new Thread(st, "窗口2");
		Thread t3 = new Thread(st, "窗口3");

		// 启动线程
		t1.start();
		t2.start();
		t3.start();
	}
}
class SellTicket implements Runnable {
	// 定义票
	private int tickets = 100;
	// 定义锁对象 ReentrantLock类是Lock接口的实现类
	private Lock lock = new ReentrantLock();

	@Override
	public void run() {
		while (true) {
			try {
				// 加锁
				lock.lock();
				if (tickets > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()
							+ "正在出售第" + (tickets--) + "张票");
				}
			} finally {
				// 释放锁
				lock.unlock();
			}
		}
	}
}

    运行结果：

JavaSE---多线程、面向对象设计思想、设计模式_第9张图片

7.4.3 死锁

    两个或两个以上的线程在争夺资源的过程中，发生的一种相互等待的现象。

    例如：

public class DieLock extends Thread {
	private boolean flag;

	public DieLock(boolean flag){
		this.flag = flag;
	}
	@Override
	public void run() {
		if(flag){
			synchronized (MyLock.objA){
				System.out.println("if objA");
				synchronized(MyLock.objB){
					System.out.println("if objB");
				}
			}
		}
		else{
			synchronized (MyLock.objB){
				System.out.println("else objB");
				synchronized(MyLock.objA){
					System.out.println("else objA");
				}
			}
		}
	}
	
}

class MyLock {
	// 创建两把锁对象
	public static final Object objA = new Object();
	public static final Object objB = new Object();
}

class DieLockDemo {
	public static void main(String[] args) {
		DieLock dl1 = new DieLock(true);
		DieLock dl2 = new DieLock(false);
		
		dl1.start();
		dl2.start();
	}
}

    运行结果：


7.5 多线程通信问题

    多线程的通信问题：不同种类的线程对同一资源的操作。

    示例：

public class StudentDemo {
	public static void main(String[] args) {
		//创建资源
		Student s = new Student();
		
		//设置和获取的类
		SetThread st = new SetThread(s);
		GetThread gt = new GetThread(s);

		//线程类
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(gt);

		//启动线程
		t1.start();
		t2.start();
	}
}
class Student {
	String name;
	int age;
}
class SetThread implements Runnable {

	private Student s;
	private int x = 0;

	public SetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (s) {
				if (x % 2 == 0) {
					s.name = "林青霞";//刚走到这里，就被别人抢到了执行权
					s.age = 27;
				} else {
					s.name = "东方不败"; //刚走到这里，就被别人抢到了执行权
					s.age = 30;
				}
				x++;
			}
		}
	}
}
class GetThread implements Runnable {
	private Student s;

	public GetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (s) {
				System.out.println(s.name + "---" + s.age);
			}
		}
	}
}

    运行结果：

JavaSE---多线程、面向对象设计思想、设计模式_第10张图片

    上面的示例代码中有两处不足：一是设置和获取的操作分别放在了SetThread和GetThread类中，如果放在Student类中会更好些；二是“东方不败----30”和 “林青霞----27”没有依次轮流出现。解决第一个问题可以将设置和获取操作封装成功能放到Student类中。为了解决第二个问题，Java提供了等待唤醒机制。

    Object类中提供了3个方法：

    wait():等待

    notify():唤醒单个线程

    notifyAll():唤醒所有线程

    这些方法的调用者必须是锁对象，所以将这三个方法放在了Object类中。

public class StudentDemo {
	public static void main(String[] args) {
		// 创建资源
		Student s = new Student();

		// 设置和获取的类
		SetThread st = new SetThread(s);
		GetThread gt = new GetThread(s);

		// 线程类
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(gt);

		// 启动线程
		t1.start();
		t2.start();
	}
}
class Student {
	private String name;
	private int age;
	private boolean flag; // 默认情况是没有数据，如果是true，说明有数据

	public synchronized void set(String name, int age) {
		// 如果有数据就等待
		if (this.flag) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		// 设置数据
		this.name = name;
		this.age = age;

		// 修改标记
		this.flag = true;
		this.notify();

	}

	public synchronized void get() {
		// 如果没有数据就等待
		if (!this.flag) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		// 获得数据
		System.out.println(this.name + "--" + this.age);

		// 修改标记
		this.flag = false;
		this.notify();
	}
}
class SetThread implements Runnable {

	private Student s;
	private int x = 0;

	public SetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			if(x%2==0){
				s.set("林青霞", 27);
			}
			else{
				s.set("东方不败",30);
			}
			x++;
		}
	}
}
class GetThread implements Runnable {
	private Student s;

	public GetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			s.get();
		}
	}
}

    运行结果：

JavaSE---多线程、面向对象设计思想、设计模式_第11张图片

7.6 线程间的状态转换图

JavaSE---多线程、面向对象设计思想、设计模式_第12张图片

    面试题1：sleep和wait的区别

    1）sleep是Thread类里的方法；wait是Object类里的方法

    2）sleep比wait的使用范围广，因为wait只能在synchronized方法或synchronized代码块中使用

    3）sleep后面必须跟一个时间，且调用sleep方法后线程不会释放锁；wait后面可以不跟时间，调用wait方法后线程会释放锁

   面试题2：join和yield的区别

    1）join是等待该线程运行结束后再继续往下走。例如t.join()就是说t线程运行完后，JVM才会继续往下走。

    2）yield是让当前线程重新回到就绪状态。执行完后该线程会与其他线程继续抢夺CPU的执行权。

7.7 线程池

7.7.1 线程池出现的原因

    程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。

7.7.2 线程池的好处

    线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。

7.7.3 实现线程池的步骤

    步骤：

    1）创建一个线程池对象，控制要创建几个线程对象。

         public static ExecutorService newFixedThreadPool(int nThreads)

    2）线程池可以执行Runnable对象或者Callable对象代表的线程

    3）结束线程池

        void shutdown()

    示例1：

public class ExecutorsDemo {
	public static void main(String[] args) {
		// 创建一个线程池对象，控制要创建几个线程对象。
		// public static ExecutorService newFixedThreadPool(int nThreads)
		ExecutorService pool = Executors.newFixedThreadPool(2);

		// 可以执行Runnable对象或者Callable对象代表的线程
		pool.submit(new MyRunnable());
		pool.submit(new MyRunnable());
		
		// 结束线程池
		pool.shutdown();
	}
}
class MyRunnable implements Runnable{
	@Override
	public void run() {
		for(int x = 0;x<100;x++){
			System.out.println(Thread.currentThread().getName()+":"+x);
		}
	}
}

    运行结果：

JavaSE---多线程、面向对象设计思想、设计模式_第13张图片

    示例2：

public class CallableDemo {
	public static void main(String[] args) {
		//创建线程池对象
		ExecutorService pool = Executors.newFixedThreadPool(2);
		
		//可以执行Runnable对象或者Callable对象代表的线程
		pool.submit(new MyCallable());
		pool.submit(new MyCallable());
		
		//结束
		pool.shutdown();
	}
}
class MyCallable implements Callable {

	@Override
	public Object call() throws Exception {
		for (int x = 0; x < 100; x++) {
			System.out.println(Thread.currentThread().getName() + ":" + x);
		}
		return null;
	}

} 
  
     运行结果： 
  
 
  
JavaSE---多线程、面向对象设计思想、设计模式_第14张图片
 
  
    练习：同时求出1-100和1-200的和，并输出到控制台。
 
  
 
  
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class MyCallableDemo {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		// 创建线程吃对象
		ExecutorService pool = Executors.newFixedThreadPool(2);

		// 执行Runnable对象或者Callable对象代表的线程
		Future f1 = pool.submit(new MyCallable(100));
		Future f2 = pool.submit(new MyCallable(200));
		
		// V get()
		Integer i1 = f1.get();
		Integer i2 = f2.get();
		
		System.out.println(i1);
		System.out.println(i2);
		// 结束
		pool.shutdown();
	}
}
class MyCallable implements Callable {

	private int number;
	
	
	public MyCallable() {
		super();
	}	

	public MyCallable(int number) {
		super();
		this.number = number;
	}
	
	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for(int x = 0;x<=number;x++){
			sum+=x;
		}
		return sum;
	}
	
}
 
  
     运行结果： 
  
 
  

 
  
7.8 匿名内部类实现多线程
 
  
    示例：
 
  
 
  
public class ThreadDemo {
	public static void main(String[] args) {
		// 继承Thread类来实现多线程
		new Thread() {
			public void run() {
				for (int x = 0; x < 100; x++) {
					System.out.println(Thread.currentThread().getName() + ":"
							+ x);
				}
			}
		}.start();

		// 实现Runnable接口来实现多线程
		new Thread(new Runnable() {

			@Override
			public void run() {
				for (int x = 0; x < 100; x++) {
					System.out.println(Thread.currentThread().getName() + ":"
							+ x);
				}
			}

		}) {
		}.start();
	}
}
    运行结果： 
  
 
  
JavaSE---多线程、面向对象设计思想、设计模式_第15张图片
     线程0和线程1在抢夺CPU资源。
 
  
    面试题：下面的代码会报错么？如果不会，运行结果是什么？
 
  
 
  
public class ThreadDemo {
	public static void main(String[] args) {
		// 更有难度的一个。下面的程序会执行
		new Thread(new Runnable() {

			@Override
			public void run() {
				for (int x = 0; x < 100; x++) {
					System.out.println("hello" + ":" + x);
				}
			}

		}) {
			public void run() {
				for (int x = 0; x < 100; x++) {
					System.out.println("world" + ":" + x);
				}
			}
		}.start();
	}
}
 
  
 
  

 
  
    上面的代码其实是两个匿名内部类实现了多线程，其中一个是继承Thread类来实现的，另一个是实现Runnable接口来实现的。
     运行结果： 
  
JavaSE---多线程、面向对象设计思想、设计模式_第16张图片
 
  
7.9 定时器
 
  
    定时器可以让我们在指定的时间做某件事情，还可以重复的做某件事情。定时器依赖Timer类和TimerTask接口。
 
  
    Timer：
 
  
    public void schedule(TimerTask task,long delay)
 
  
    public void schedule(TimerTask task,long delay,long period)
 
  
    public void cancel()
 
  
    TimerTask:
 
  
    public abstract void run()：此计时器任务要执行的操作。
 
  
    示例：
 
  
 
  
public class TimerDemo {
	public static void main(String[] args) {
		// 创建定时器对象
		Timer t = new Timer();
		// 3秒后执行爆炸
		// t.schedule(new MyTask(), 3000);
		// 3秒后执行爆炸并结束任务
		t.schedule(new MyTask(t), 3000);
	}
}

// 做一个任务
class MyTask extends TimerTask {

	private Timer t;

	public MyTask() {
	}

	public MyTask(Timer t) {
		this.t = t;
	}

	@Override
	public void run() {
		System.out.println("beng,爆炸了");
		t.cancel();
	}
}
 
  
     运行结果： 
  
 
  

 
  
    示例2：
 
  
 
  
import java.util.Timer;
import java.util.TimerTask;

public class TimerDemo2 {
	public static void main(String[] args) {
		// 创建定时器对象
		Timer t = new Timer();
		// 3秒后执行爆炸任务第一次，每隔2秒再继续炸
		t.schedule(new MyTask2(), 3000, 2000);
	}
}

// 做一个任务
class MyTask2 extends TimerTask {
	@Override
	public void run() {
		System.out.println("beng,爆炸了");
	}
}
 
  
 
  
    运行结果：
 
  
JavaSE---多线程、面向对象设计思想、设计模式_第17张图片
 
  
    练习：在指定的时间删除我们的指定目录
 
  
 
  
import java.io.File;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

class DeleteFolder extends TimerTask {
	
	private Timer t;

	public DeleteFolder() {}

	public DeleteFolder(Timer t) {
		this.t = t;
	}

	@Override
	public void run() {
		File srcFolder = new File("demo");
		deleteFolder(srcFolder);
		t.cancel();
	}

	// 递归删除目录
	private void deleteFolder(File srcFolder) {
		File[] fileArray = srcFolder.listFiles();
		if (fileArray != null) {
			for (File file : fileArray) {
				if (file.isDirectory()) {
					deleteFolder(file);
				} else {
					System.out.println(file.getName() + ":" + file.delete());
				}
			}
			System.out.println(srcFolder.getName() + ":" + srcFolder.delete());
		}
	}
}

public class TimerTest {
	public static void main(String[] args) throws ParseException {
		Timer t = new Timer();

		String s = "2015-9-18 9:15:50";
		SimpleDateFormat sdf = new SimpleDateFormat("yy-MM-dd HH:mm:ss");
		Date d = sdf.parse(s);
		
		t.schedule(new DeleteFolder(t), d);
	}
}
 
  
 
  

 
  
7.10 线程不安全类转为线程安全类
 
  
    常见的线程安全类有：StringBuffer、Vector、Hashtable。虽然使用线程安全类不会有多线程的安全问题，但是效率有点低。Collections类提供了一个synchronizedXxx的方法，可以通过该方法建立一个安全的线程类。
 
  
    示例：建立一个线程安全的ArrayList类
 
  
 
  
import java.util.ArrayList;
import java.util.Collections;
import java.util.Hashtable;
import java.util.List;
import java.util.Vector;

public class ThreadDemo {
	public static void main(String[] args) {
		// 线程安全的类
		StringBuffer sb = new StringBuffer();
		Vector v = new Vector();
		Hashtable h = new Hashtable();

		// Vector是线程安全的时候才去考虑使用的，但是我还说过即使要安全，我也不用你
		// 那么到底用谁呢?
		// public static  List synchronizedList(List list)
		List list1 = new ArrayList();// 线程不安全
		List list2 = Collections
				.synchronizedList(new ArrayList());// 线程安全
	}
}
 
  
 
  
 
  
 
  
 
  
8. 面向对象增强
 
  
 
  
8.1 面向对象设计思想
 
  
    在实际的开发中，我们要想更深入的了解面向对象思想，就必须熟悉前人总结过的面向对象的思想的设计原则，包括：单一职责原则、开闭原则、里氏替换原则、依赖注入原则、接口分离原则、迪米特原则。
 
  
    单一职责原则
 
  
    其实就是开发人员经常说的”高内聚，低耦合”。也就是说，每个类应该只有一个职责，对外只能提供一种功能，而引起类变化的原因应该只有一个。在设计模式中，所有的设计模式都遵循这一原则。
 
  
    开闭原则
 
  
    核心思想是：一个对象对扩展开放，对修改关闭。其实开闭原则的意思就是：对类的改动是通过增加代码进行的，而不是修改现有代码。也就是说软件开发人员一旦写出了可以运行的代码，就不应该去改动它，而是要保证它能一直运行下去，如何能够做到这一点呢?这就需要借助于抽象和多态，即把可能变化的内容抽象出来，从而使抽象的部分是相对稳定的，而具体的实现则是可以改变和扩展的。
 
  
    里氏替换原则
 
  
    核心思想：在任何父类出现的地方都可以用它的子类来替代。其实就是说：同一个继承体系中的对象应该有共同的行为特征。
 
  
    依赖注入原则
 
  
    核心思想：要依赖于抽象，不要依赖于具体实现。其实就是说：在应用程序中，所有的类如果使用或依赖于其他的类，则应该依赖这些其他类的抽象类，而不是这些其他类的具体类。为了实现这一原则，就要求我们在编程的时候针对抽象类或者接口编程，而不是针对具体实现编程。
 
  
    接口分离原则
 
  
    核心思想：不应该强迫程序依赖它们不需要使用的方法。其实就是说：一个接口不需要提供太多的行为，一个接口应该只提供一种对外的功能，不应该把所有的操作都封装到一个接口中。
 
  
    迪米特原则
 
  
    核心思想：一个对象应当对其他对象尽可能少的了解。其实就是说：降低各个对象之间的耦合，提高系统的可维护性。在模块之间应该只通过接口编程，而不理会模块的内部工作原理，它可以使各个模块耦合度降到最低，促进软件的复用。
 
  
8.2 设计模式
 
  
8.2.1 设计模式概述
 
  
    设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
     设计模式不是一种方法和技术，而是一种思想。
     设计模式和具体的语言无关，学习设计模式就是要建立面向对象的思想，尽可能的面向接口编程，低耦合，高内聚，使设计的程序可复用。
     学习设计模式能够促进对面向对象思想的理解，反之亦然。它们相辅相成。
 
  
8.2.2 设计模式的几个要素
 
  
    名字：必须有一个简单，有意义的名字
     问题：描述在何时使用模式
     解决方案：描述设计的组成部分以及如何解决问题
     效果：描述模式的效果以及优缺点
 
  
8.2.3 设计模式的分类
 
  
    创建型模式：对象的创建
     结构型模式：对象的组成(结构)
     行为型模式：对象的行为
 
  
8.2.4 几个常见的设计模式
 
  
1. 简单工厂模式
 
  
    1）简单工厂模式概述
 
  
    简单工厂模式又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例。
 
  
    2）简单工厂模式代码实现
 
  
 
  
public class AnimalDemo {
	public static void main(String[] args) {
		// 使用工厂
		Animal a = AnimalFactory.creatAnimal("dog");
		a.eat();
		a = AnimalFactory.creatAnimal("cat");
		a.eat();

		// NullPointerException
		a = AnimalFactory.creatAnimal("pig");
		if (a != null) {
			a.eat();
		} else {
			System.out.println("对不起，暂时不提供这种动物");
		}

	}
}
class AnimalFactory {
	private AnimalFactory(){};

	public static Animal creatAnimal(String type){
		if("dog".equals(type)){
			return new Dog();
		}else if("cat".equals(type)){
			return new Cat();
		}else{
			return null;
		}
	}
}
abstract class Animal {
	public abstract void eat();
}
class Dog extends Animal {

	@Override
	public void eat() {
		System.out.println("狗吃肉");
	}

}
class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}
 
  
     运行结果： 
  
 
  
JavaSE---多线程、面向对象设计思想、设计模式_第18张图片
 
  
    3）简单工厂模式优缺点
 
  
    优点：客户端不需要在负责对象的创建，从而明确了各个类的职责。
 
  
    缺点：这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护。
 
  
2. 工厂方法模式
 
  
    1）工厂方法模式概述
 
  
    工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
 
  
    2）工厂方法模式代码实现
 
  
 
  
public class AnimalDemo {
	public static void main(String[] args) {
		// 需求：我要买只狗
		Factory f= new DogFactory();
		Animal a = f.creatAnimal();
		a.eat();
		System.out.println("-------");
		//需求：我要买只猫
		f = new CatFactory();
		a = f.creatAnimal();
		a.eat();
	}
}
interface Factory {
	public abstract Animal creatAnimal();
}
class DogFactory implements Factory {

	@Override
	public Animal creatAnimal() {
		return new Dog();
	}
	
}
class CatFactory implements Factory {

	@Override
	public Animal creatAnimal() {
		return new Cat();
	}

}
public abstract class Animal {
	public abstract void eat();
}
class Dog extends Animal {

	@Override
	public void eat() {
		System.out.println("狗吃肉");
	}

}
class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}

}
 
  
     运行结果： 
  
 
  

 
  
    3）工厂方法模式优缺点
 
  
    优点：客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性 
 
  
    缺点：需要额外的编写代码，增加了工作量
 
  
3. 单例设计模式
 
  
    1）单例设计模式概述
 
  
    单例模式就是要确保类在内存中只有一个对象，该实例必须自动创建，并且对外提供。
 
  
    2）单例设计模式代码实现
 
  
    步骤：a、把构造方法私有b、在成员位置自己创建一个对象c、通过一个公共的方法提供访问
 
  
     饿汉式：
 
  
 
  
public class StudentDemo {
	public static void main(String[] args) {

		// 通过单例设计模式得到对象
		Student s1 = Student.getStudent();
		Student s2 = Student.getStudent();
		System.out.println(s1 == s2);
	}
}
class Student {
	// 构造方法私有
	private Student() {
	};

	// 在成员位置自己创建一个对象
	// 静态方法只能访问静态成员变量，加静态
	// 为了不让外界直接访问修改这个值，加private
	private static Student s = new Student();

	// 通过一个公共的方法提供访问
	public static Student getStudent() {
		return s;
	}
}
 
  
     运行结果： 
  
 
  

 
  
    懒汉式：
 
  
 
  
public class Teacher {
	private Teacher() {
	}

	private static Teacher t = null;

	public synchronized static Teacher getTeacher() {
		
		if (t == null) {
			t = new Teacher();
		}
		return t;
	}
}
class TeacherDemo {
	public static void main(String[] args) {
		Teacher t1 = Teacher.getTeacher();
		Teacher t2 = Teacher.getTeacher();
		System.out.println(t1 == t2);
	}
}
 
  
     运行结果： 
  
 
  
    
 
  

 
  
    注意：开发的时候用饿汉式，面试的时候更多会问懒汉式相关的问题。
 
  
    3）单例设计模式优缺点
 
  
    优点：在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
 
  
    缺点：没有抽象层，因此扩展很难。职责过重，在一定程序上违背了单一职责。
 
  
    4）单例设计模式在Java源码中的应用
 
  
    Java源码中的Runtime类中创建新对象就用到了饿汉式。
 
  
    Runtime:每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。其中有一个方法是exec(String command):在单独的进程中执行指定的字符串命令
 
  
    示例：
 
  
 
  
import java.io.IOException;

public class RuntimeDemo {
	public static void main(String[] args) throws IOException {
		Runtime r = Runtime.getRuntime();
		// r.exec("winmine");
		// r.exec("notepad");//打开记事本
		// r.exec("calc");//打开计算器
		r.exec("shutdown -s -t 1000");// 定时关机
		r.exec("shutdown a");// 取消关机命令
	}
}
 
  
 
  
 
  

 
  

 
  
    
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Java)

        

            

                
    
                    
  • 如何解决Webview和H5缓存问题，确保每次加载最新版本的资源
                        qq_39279448
缓存
                        
    WebView用于加载H5页面是常见的做法，它能够加载远程的HTML、CSS、JavaScript资源，并且让Web应用嵌入到原生App中。然而，WebView的缓存机制有时会导致用户看到的是旧版本的页面或资源，尤其是在H5发版后，iOS端用户可能仍然加载到缓存的旧页面，造成了不一致的体验。本篇文章将详细分析这个问题的根本原因，并介绍一些有效的缓存处理策略，确保每次加载的都是最新的资源。一、Web
    
                    
    • 
                    
  • 破解编程语言“鄙视链”：深度剖析其成因与背后的逻辑
                        TravisBytes
其他网络协议网络协程coroutinec++
                        
    在编程世界里，各种编程语言的使用者之间似乎存在着一条无形的“鄙视链”。从古老神秘的C到灵动便捷的Python，从严谨规范的Java到天马行空的Ruby，不同语言的拥趸们总是在暗自较量。这条所谓的“鄙视链”究竟源自何处？它是基于语言特性的理性分级，还是仅仅是程序员们的主观臆断？本文将深入探讨“鄙视链”的成因，揭示其背后的逻辑与动因，帮助读者全面理解这一现象。目录1.历史与传统的影响2.语言特性的差异
    
                    
    • 
                    
  • 编程语言发展史之：编程语言的未来趋势
                        AI天才研究院
AI大模型企业级应用开发实战大数据人工智能语言模型JavaPython架构设计
                        
    作者：禅与计算机程序设计艺术文章目录1.简介概述计算编程语言发展的主要里程碑2.编程语言的历史2.1编程语言的出现2.2第一代编程语言——FORTRAN2.3第二代编程语言——COBOL2.4第三代编程语言——PASCAL2.5第四代编程语言——C++、Java、C#、Python、Ruby等2.6模块化编程语言2.7跨平台语言2.8编程语言的分类3.编程语言的发展阶段及其性质编程语言的发展阶段及
    
                    
    • 
                    
  • java实现aes-128-ecb_电信IOT平台编解码插件，JAVA实现AES128-ECB-PKCS7Padding加解密代码...
                        尼不要逗了~~~

                        
    packagecom.thrid.party.codec.demo;importjava.io.UnsupportedEncodingException;importjava.security.InvalidKeyException;importjava.security.NoSuchAlgorithmException;importjava.security.SecureRandom;impor
    
                    
    • 
                    
  • 【爬虫】针对FingerprintJS反爬，selenium破解策略
                        steamedobun
项目管理爬虫爬虫selenium测试工具
                        
    目录FingerprintJS原理概述Selenium基础与应对思路代码实现实战（结合Selenium和UndetectedChromedriver绕过FingerprintJS）Canvas指纹随机化FingerprintJS原理概述FingerprintJS主要通过收集浏览器的各种特征信息来生成独一无二的指纹，这些信息包括但不限于：浏览器版本信息：不同浏览器版本在处理网页元素、执行JavaSc
    
                    
    • 
                    
  • C、C++、Java到Python，编程入门学习什么语言好?
                        明天会比今天更好
C/C++编程入门编程语言程序员
                        
    最近，TIOBE更新了7月的编程语言榜单，常年霸榜的C、Java和Python依然蝉联前三位。万万没想到的是，R语言居然冲到了第八位，创下了史上最佳记录。而且后续随着业内对数据统计和挖掘需求的上涨，R语言热度颇有些势不可挡的架势。然而作为程序员吃饭的工具，编程语言之间也形成了某种鄙视链，各大论坛里弥漫着剑拔弩张的气氛，众口难调。也难怪有很多初学者会有疑惑，为什么会有这么多编程语言，我到底应该学什么
    
                    
    • 
                    
  • Java虚拟机的历程（jvm01）
                        小猫猫猫◍˃ᵕ˂◍
java开发语言
                        
    Java虚拟机的历程（jvm01）Java虚拟机（JVM）作为Java语言的核心技术之一，自诞生以来经历了多次迭代与演变。不同的虚拟机在性能、功能以及适用场景上各有侧重。本文将介绍Java虚拟机发展历程中的一些重要虚拟机，涵盖经典虚拟机（ClassicVM、ExactVM）、影响力最大的虚拟机（HotSpot、JRockit、J9）、移动端虚拟机（KVM）、性能最高的虚拟机（Azul、Liquid
    
                    
    • 
                    
  • prometheus 服务java服务接入基础镜像配置
                        窗外的寒风
prometheusjavapython
                        
    环境变量设置：如果不经常修改配置，推荐在java镜像中把prometheus配置通过环境变量的方式统一配置，可以使用下面的参数，把端口进行暴漏（配置安全检查端口9998，启用所有安全检查接口，配置普罗米修斯的监测间隔，设置java服务名，把普罗米修斯的接口提升到根目录）ENVSPRING_APPLICATION_JSON='{"management.server.port":"9998","man
    
                    
    • 
                    
  • leetcode——二叉树的直径（java）
                        gentle_ice
leetcode算法java数据结构
                        
    给你一棵二叉树的根节点，返回该树的直径。二叉树的直径是指树中任意两个节点之间最长路径的长度。这条路径可能经过也可能不经过根节点root。两节点之间路径的长度由它们之间边数表示。示例1：输入：root=[1,2,3,4,5]输出：3解释：3，取路径[4,2,1,3]或[5,2,1,3]的长度。示例2：输入：root=[1,2]输出：1解题方法：（递归）1.递归入口，当前根节点非空，否则返回-1。2.
    
                    
    • 
                    
  • 赛博算卦之周易六十四卦JAVA实现：六幺算尽天下事，梅花化解天下苦。
                        钮钴禄·爱因斯晨
java学习java
                        
    佬们过年好呀~新年第一篇博客让我们来场赛博算命吧！更多文章：个人主页系列文章：JAVA专栏欢迎各位大佬来访哦~互三必回！！！文章目录#一、文化背景概述1.文化起源2.起卦步骤#二、卦象解读#三、justdoit!代码展示1.解析2.代码实现#四、总结#参考文献#一、文化背景概述1.文化起源六爻和六十四卦的文化起源可追溯至远古，那时人们为预测未来开展占卜，从龟甲兽骨裂纹到蓍草竹签筮法，逐步孕育了爻的
    
                    
    • 
                    
  • java工作流模式、背包模式、适配器工厂模式整合架构，让服务任务编排更便捷
                        窗外的寒风
适配器模式架构
                        
    工作流和背包模式虽然不在23种常用设计模式中，但是在对任务编排处理类的业务代码使用起来是非常有用的。下面给大家介绍下工作流模式：例如，我之前有个项目需要对模型进行转换，因为不同配置的模型需要使用的转换方法不同，且单个模型需要经历多次的执行转换脚本，那就可以把每个脚本抽离出来封装为工作流中的一个字节点，通过对节点编排适应不同的转换任务，代码流程清晰，转换流程通过配置文件进行配置。背包模式呢，其实并不
    
                    
    • 
                    
  • leetcode——二叉树的最大深度（java）
                        gentle_ice
javaleetcode算法数据结构
                        
    给定一个二叉树root，返回其最大深度。二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。示例1：输入：root=[3,9,20,null,null,15,7]输出：3示例2：输入：root=[1,null,2]输出：2解题方法：（自底向上递归）1.递归入口：当前节点非空；否则，返回0；2.然后开始进入左子树递归获取左子树的深度；进入右子树递归获取右子树的深度。3.最后返回左子树与右
    
                    
    • 
                    
  • JAVA常见面试题-RabbitMQ
                        waviss
JAVA常见面试题java开发语言面试
                        
    RabbitMQ数据类型Map：如果发送的消息类型是map类型，可以通过SerializationUtils.deserialize方法将消息转换成map类型。String（含json字符串类型）：RabbitMQ原理RabbitMQ大致分为生产者、队列、消费者，在实际情况中生产者将消息发送到Exchange（交换器），再通过Banding操作将与队列关联起来。在绑定（Banding）Exchan
    
                    
    • 
                    
  • java语句翻译_java基础语句翻译
                        我爱专利
java语句翻译
                        
    publicstaticvoidmain(String[]args){System.out.println("人生中的第一个代码-----");}}package包的关键字类文件的首行位置com.zhiyou100包名；结束标志语句的结束com.zhiyou100com。zhiyou100包说明当前类HelloWorld是在com。zhiyou100包内public关键字修饰符公共的修饰符权限任何
    
                    
    • 
                    
  • Java面试题-rabbitmq-001
                        码者人生
面试题java技术面试题集java面试题java面试题rabbitmq
                        
    使用RabbitMQ有什么好处？消息基于什么传输？消息怎么路由？如何做到信息的可靠性？确保消息正确地发送至RabbitMQ？确保消息接受方消费了消息？休息不丢失不重复？如何避免消息重复投递或重复消费？为什么使用集群RabbitMQ节点不完全拷贝特性集群节点类型单节点系统必须是磁盘节点?RabbitMQ要求集群中至少有一个磁盘节点?mq的缺点
    
                    
    • 
                    
  • NPM 使用介绍
                        lly202406
开发语言
                        
    NPM使用介绍引言NPM（NodePackageManager）是Node.js生态系统中的一个核心工具，用于管理JavaScript项目的依赖包。无论是开发一个小型脚本还是构建大型应用程序，NPM都能极大地提高开发效率。本文将详细介绍NPM的使用方法，包括安装、配置、依赖管理、包发布等，帮助您快速上手NPM。安装NPM在开始使用NPM之前，您需要确保已经安装了Node.js。NPM与Node.j
    
                    
    • 
                    
  • 【华为机试真题JavaScript】尼科彻斯定理
                        forest_long
华为机试真题-JS动态规划javascriptpythonjava华为
                        
    目录题目描述输入描述输出描述参考示例参考代码机试介绍写在最后题目描述验证尼科彻斯定理，即：任何一个整数m的立方都可以写成m个连续奇数之和。例如：1^3=12^3=3+53^3=7+9+114^3=13+15+17+19输入一个正整数m（m≤100），将m的立方写成m个连续奇数之和的形式输出。数据范围：1≤m≤100进阶：时间复杂度：O(m)，空间复杂度：O(1)输入描述输入一个int整数输出描述输
    
                    
    • 
                    
  • SpringBoot：RabbitMQ-延迟队列
                        csdnlaoban
程序员java-rabbitmqspringbootrabbitmq
                        
    《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！com.alibabafastjson1.2.46org.springframework.bootspring-boot-starter-weborg.springframework.bootspring-boot-starter-testtest属性配置在application.propertie
    
                    
    • 
                    
  • java.lang.NoSuchMethodException: org.apache.catalina.deploy.WebXml addServlet
                        漫无目的行走的月亮

                        
    java.lang.NoSuchMethodException:org.apache.catalina.deploy.WebXmladdServlet-------------------------------------------------------------------------------------------------------------------?解决此异常的方法是
    
                    
    • 
                    
  • Java代码-八种数组排序方法
                        忧郁小王子x
算法java
                        
    一.冒泡排序1.1概述对于一组，多次将数组中的数两两比较，较大或者较小的数向后排（经过一轮比较后，最大/最小的数就会到结尾），循环直至有序排列。1.2代码实现importjava.lang.reflect.Array;importjava.util.Arrays;importjava.util.Scanner;publicclassmaopao{publicstaticvoidmain(Strin
    
                    
    • 
                    
  • 【Java】Java Lambda List转List
                        奔向理想的星辰大海
云原生技术研发开发语言java
                        
    JavaLambdaList转List的实现方法引言在Java开发中，Lambda表达式是一种非常强大和常用的特性，它允许我们以一种更加简洁和灵活的方式编写代码。在处理集合类数据时，我们经常需要对列表进行转换操作，将其转换为另一种类型的列表。本文将介绍如何使用JavaLambda表达式将一个List转换为另一个List。实现步骤为了更好地理解整个过程，我们可以使用表格来展示每个步骤的具体操作。下面
    
                    
    • 
                    
  • 面向切面之集中式登录架构设计
                        roy_xing
android架构
                        
    普通登录流程图集中式登录流程图把共有的业务通过AOP统一管理这里我们就需要使用AspectJ来实现面向切面的集中式登录什么是AspectJAspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。Aspect是切面是切入点(PointCuts)和通知(Advice)的集合。Pointcut切入点通
    
                    
    • 
                    
  • 语言模型与向量模型：深入解析与实例剖析
                        ♢.＊
语言模型人工智能自然语言处理
                        
    亲爱的小伙伴们，在求知的漫漫旅途中，若你对深度学习的奥秘、Java与Python的奇妙世界，亦或是读研论文的撰写攻略有所探寻，那不妨给我一个小小的关注吧。我会精心筹备，在未来的日子里不定期地为大家呈上这些领域的知识宝藏与实用经验分享。每一个点赞，都如同春日里的一缕阳光，给予我满满的动力与温暖，让我们在学习成长的道路上相伴而行，共同进步✨。期待你的关注与点赞哟！在自然语言处理领域，语言模型和向量模型
    
                    
    • 
                    
  • Java二维数组排序
                        purpleFairyx
二维数组排序比较器Lambda表达式
                        
    今天在刷力扣的时候，有道题卡住了，没办法去看题解，发现题解是将其二维数组排序了，我才猛然发现我还不了解二位数组排序的知识。所以来记录一下。答案中的代码是这样的，假设需要排序的数组intervals：int[][]intervals={{2,3},{2,9},{4,5},{3,7},{6,7},{8,9},{1,10}};Arrays.sort(intervals,newComparator(){@
    
                    
    • 
                    
  • 【Elasticsearch 】自定义分词器
                        程风破～
Elasticsearchelasticsearch大数据搜索引擎
                        
    博主简介：CSDN博客专家，历代文学网（PC端可以访问：https://literature.sinhy.com/#/?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于分
    
                    
    • 
                    
  • 如何写好C++类
                        铮铭
c++
                        
    先讲一个笑话：同时学习两年Java的程序员在一起讨论的是面向对象和设计模式，而同时学习两年C++的程序员，在一起讨论的是template和各种语言规范到底怎么回事情。下面就从公开的资料中撸一撸如何写好一个c++类，从头文件（.h）需要包含的文件开始：1、#define保护：符号的命名最好是以下形式：___H_，比如foo项目中的foo/src/bar/baz.h文件应该这样保护：#ifndefFO
    
                    
    • 
                    
  • IDEA+Java+SSH+Bootstrap+Mysql实现在线考试系统(含论文)
                        2401_89694162
javaintellij-ideassh
                        
    –Recordsoft_managerINSERTINTOt_managerVALUES(1,‘管理员’,‘admin’,‘admin’);–Tablestructurefort_paperDROPTABLEIFEXISTSt_paper;CREATETABLEt_paper(idint(11)NOTNULLAUTO_INCREMENT,joinDatedatetime(0)NULLDEFAULT
    
                    
    • 
                    
  • Python 调用常见大模型 API 全解析
                        ♢.＊
python开发语言语言模型nlp
                        
    亲爱的小伙伴们，在求知的漫漫旅途中，若你对深度学习的奥秘、JAVA、PYTHON与SAP的奇妙世界，亦或是读研论文的撰写攻略有所探寻，那不妨给我一个小小的关注吧。我会精心筹备，在未来的日子里不定期地为大家呈上这些领域的知识宝藏与实用经验分享。每一个点赞，都如同春日里的一缕阳光，给予我满满的动力与温暖，让我们在学习成长的道路上相伴而行，共同进步✨。期待你的关注与点赞哟！调用通义千问接口获取APIKe
    
                    
    • 
                    
  • java FastJSON自定义序列化和反序列化(扩展点)方法总结！10个步骤让你轻松掌握
                        墨瑾轩
一起学学Java【一】开发语言java
                        
    关注墨瑾轩，带你探索编程的奥秘！超萌技术攻略，轻松晋级编程高手技术宝库已备好，就等你来挖掘订阅墨瑾轩，智趣学习不孤单即刻启航，编程之旅更有趣嘿，小伙伴们！今天我们要一起探讨一个非常实用的话题——如何使用FastJSON自定义序列化和反序列化。你知道吗？FastJSON是阿里巴巴开源的一个高性能JSON库，广泛应用于Java项目中。虽然FastJSON提供了丰富的内置功能，但有时候我们还需要根据具体
    
                    
    • 
                    
  • java编程根据订单编号查询订单状态_java生成订单编号工具
                        赖明星

                        
    直接code，用了线程执行，加上了锁publicclassTestOrderextendsThread{privatestaticlongorderNum=0l;privatestaticStringdate;publicstaticvoidmain(String[]args)throwsInterruptedException{for(inti=0;i<10000;i++){System.out
    
                    
    • 
                                
  • Enum用法
                                    不懂事的小屁孩
enum
                                    
    以前的时候知道enum，但是真心不怎么用，在实际开发中，经常会用到以下代码: 
 
protected final static String XJ = "XJ";
protected final static String YHK = "YHK";
protected final static String PQ = "PQ";

    
                                
    • 
                                
  • 【Spark九十七】RDD API之aggregateByKey
                                    bit1129
spark
                                    
    1. aggregateByKey的运行机制 
  
  /**
   * Aggregate the values of each key, using given combine functions and a neutral "zero value".
   * This function can return a different result type
    
                                
    • 
                                
  • hive创建表是报错： Specified key was too long; max key length is 767 bytes
                                    daizj
hive
                                    
    今天在hive客户端创建表时报错，具体操作如下 
  
hive> create table test2(id string); 
FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. MetaException(message:javax.jdo.JDODataSto
    
                                
    • 
                                
  • Map 与 JavaBean之间的转换
                                    周凡杨
java自省转换反射
                                    
       
最近项目里需要一个工具类，它的功能是传入一个Map后可以返回一个JavaBean对象。很喜欢写这样的Java服务，首先我想到的是要通过Java 的反射去实现匿名类的方法调用，这样才可以把Map里的值set 到JavaBean里。其实这里用Java的自省会更方便，下面两个方法就是一个通过反射，一个通过自省来实现本功能。 
1：JavaBean类 
 
1 &nb
    
                                
    • 
                                
  • java连接ftp下载
                                    g21121
java
                                    
    有的时候需要用到java连接ftp服务器下载，上传一些操作，下面写了一个小例子。 
/** ftp服务器地址 */
private String ftpHost;
/** ftp服务器用户名 */
private String ftpName;
/** ftp服务器密码 */
private String ftpPass;
/** ftp根目录 */
private String f
    
                                
    • 
                                
  • web报表工具FineReport使用中遇到的常见报错及解决办法（二）
                                    老A不折腾
finereportweb报表java报表总结
                                    
      
抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。 
  
出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 
  
1、没有返回数据集： 
在存储过程中的操作语句之前加上set nocount on 或者在数据集exec调用存储过程的前面加上这句。当S
    
                                
    • 
                                
  • linux 系统cpu 内存等信息查看
                                    墙头上一根草
cpu内存liunx
                                    
    1 查看CPU 
　　1.1 查看CPU个数 
　　# cat /proc/cpuinfo | grep "physical id" | uniq | wc -l 
　　2 
　　**uniq命令：删除重复行;wc –l命令：统计行数** 
　　1.2 查看CPU核数 
　　# cat /proc/cpuinfo | grep "cpu cores" | u
    
                                
    • 
                                
  • Spring中的AOP
                                    aijuans
springAOP
                                    
       
Spring中的AOP  
Written by Tony Jiang @ 2012-1-18 （转）何为AOP 
AOP，面向切面编程。 
在不改动代码的前提下，灵活的在现有代码的执行顺序前后，添加进新规机能。 
来一个简单的Sample: 
目标类：    
[java]  
view plain 
copy 
print 
?     
 
 package&nb
    
                                
    • 
                                
  • placeholder(HTML 5) IE 兼容插件
                                    alxw4616
JavaScriptjquery jQuery插件
                                    
    placeholder 这个属性被越来越频繁的使用.
但为做HTML 5 特性IE没能实现这东西.
以下的jQuery插件就是用来在IE上实现该属性的. 

/**
 * [placeholder(HTML 5) IE 实现.IE9以下通过测试.]
 * v 1.0 by oTwo 2014年7月31日 11:45:29
 */
$.fn.placeholder = function
    
                                
    • 
                                
  • Object类,值域,泛型等总结(适合有基础的人看)
                                    百合不是茶
泛型的继承和通配符变量的值域Object类转换
                                    
    java的作用域在编程的时候经常会遇到,而我经常会搞不清楚这个 
问题,所以在家的这几天回忆一下过去不知道的每个小知识点 
  
变量的值域; 
  
package 基础;

/**
 * 作用域的范围
 * 
 * @author Administrator
 * 
 */
public class zuoyongyu {
public static vo
    
                                
    • 
                                
  • JDK1.5 Condition接口
                                    bijian1013
javathreadConditionjava多线程
                                    
    Condition 将 Object 监视器方法（wait、notify和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set （wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。 
条件（也称为条件队列或条件变量）为线程提供了一
    
                                
    • 
                                
  • 开源中国OSC源创会记录
                                    bijian1013
hadoopsparkMemSQL
                                    
    一.Strata+Hadoop World（SHW）大会 
        是全世界最大的大数据大会之一。SHW大会为各种技术提供了深度交流的机会，还会看到最领先的大数据技术、最广泛的应用场景、最有趣的用例教学以及最全面的大数据行业和趋势探讨。        
  
二.Hadoop 
  &nbs
    
                                
    • 
                                
  • 【Java范型七】范型消除
                                    bit1129
java
                                    
    范型是Java1.5引入的语言特性，它是编译时的一个语法现象，也就是说，对于一个类，不管是范型类还是非范型类，编译得到的字节码是一样的，差别仅在于通过范型这种语法来进行编译时的类型检查，在运行时是没有范型或者类型参数这个说法的。 
范型跟反射刚好相反，反射是一种运行时行为，所以编译时不能访问的变量或者方法(比如private)，在运行时通过反射是可以访问的，也就是说，可见性也是一种编译时的行为，在
    
                                
    • 
                                
  • 【Spark九十四】spark-sql工具的使用
                                    bit1129
spark
                                    
    spark-sql是Spark bin目录下的一个可执行脚本，它的目的是通过这个脚本执行Hive的命令，即原来通过 
hive>输入的指令可以通过spark-sql>输入的指令来完成。 
spark-sql可以使用内置的Hive metadata-store，也可以使用已经独立安装的Hive的metadata store 
  
关于Hive build into Spark
    
                                
    • 
                                
  • js做的各种倒计时
                                    ronin47
js 倒计时
                                    
     
 第一种：精确到秒的javascript倒计时代码   
    
 HTML代码:   
 <form name="form1">   
 <div align="center" align="middle"
    
                                
    • 
                                
  • java-37.有n 个长为m+1 的字符串，如果某个字符串的最后m 个字符与某个字符串的前m 个字符匹配，则两个字符串可以联接
                                    bylijinnan
java
                                    
    
public class MaxCatenate {  
  
	/*
	 * Q.37 有n 个长为m+1 的字符串，如果某个字符串的最后m 个字符与某个字符串的前m 个字符匹配，则两个字符串可以联接，
	 * 问这n 个字符串最多可以连成一个多长的字符串，如果出现循环，则返回错误。
	 */
    public static void main(String[] args){
    
                                
    • 
                                
  • mongoDB安装
                                    开窍的石头
mongodb安装 基本操作
                                    
    mongoDB的安装 
   
      1:mongoDB下载   https://www.mongodb.org/downloads   
      2:下载mongoDB下载后解压 
    
    
                                
    • 
                                
  • [开源项目]引擎的关键意义
                                    comsci
开源项目
                                    
     
 
     一个系统，最核心的东西就是引擎。。。。。 
 
      而要设计和制造出引擎，最关键的是要坚持。。。。。。 
 
      现在最先进的引擎技术，也是从莱特兄弟那里出现的，但是中间一直没有断过研发的 
   
    
                                
    • 
                                
  • 软件度量的一些方法
                                    cuiyadll
方法
                                    
    软件度量的一些方法http://cuiyingfeng.blog.51cto.com/43841/6775/在前面我们已介绍了组成软件度量的几个方面。在这里我们将先给出关于这几个方面的一个纲要介绍。在后面我们还会作进一步具体的阐述。当我们不从高层次的概念级来看软件度量及其目标的时候，我们很容易把这些活动看成是不同而且毫不相干的。我们现在希望表明他们是怎样恰如其分地嵌入我们的框架的。也就是我们度量的
    
                                
    • 
                                
  • XSD中的targetNameSpace解释
                                    darrenzhu
xmlnamespacexsdtargetnamespace
                                    
    参考链接:
http://blog.csdn.net/colin1014/article/details/357694 
xsd文件中定义了一个targetNameSpace后，其内部定义的元素，属性，类型等都属于该targetNameSpace,其自身或外部xsd文件使用这些元素，属性等都必须从定义的targetNameSpace中找： 
 
 
例如：以下xsd文件，就出现了该错误，即便是在一
    
                                
    • 
                                
  • 什么是RAID0、RAID1、RAID0+1、RAID5，等磁盘阵列模式?
                                    dcj3sjt126com
raid
                                    
    RAID 1又称为Mirror或Mirroring，它的宗旨是最大限度的保证用户数据的可用性和可修复性。 RAID 1的操作方式是把用户写入硬盘的数据百分之百地自动复制到另外一个硬盘上。由于对存储的数据进行百分之百的备份，在所有RAID级别中，RAID 1提供最高的数据安全保障。同样，由于数据的百分之百备份，备份数据占了总存储空间的一半，因而，Mirror的磁盘空间利用率低，存储成本高。 
Mir
    
                                
    • 
                                
  • yii2 restful web服务快速入门
                                    dcj3sjt126com
PHPyii2
                                    
    快速入门 
Yii 提供了一整套用来简化实现 RESTful 风格的 Web Service 服务的 API。 特别是，Yii 支持以下关于 RESTful 风格的 API： 
 
 支持 Active Record 类的通用API的快速原型 
 涉及的响应格式（在默认情况下支持 JSON 和 XML) 
 支持可选输出字段的定制对象序列化 
 适当的格式的数据采集和验证错误 
    
                                
    • 
                                
  • MongoDB查询(3)——内嵌文档查询（七）
                                    eksliang
MongoDB查询内嵌文档MongoDB查询内嵌数组
                                    
    MongoDB查询内嵌文档 
转载请出自出处：http://eksliang.iteye.com/blog/2177301 一、概述 
       有两种方法可以查询内嵌文档：查询整个文档；针对键值对进行查询。这两种方式是不同的，下面我通过例子进行分别说明。 
  二、查询整个文档 
例如:有如下文档 
db.emp.insert({
	&qu
    
                                
    • 
                                
  • android4.4从系统图库无法加载图片的问题
                                    gundumw100
android
                                    
    典型的使用场景就是要设置一个头像，头像需要从系统图库或者拍照获得，在android4.4之前，我用的代码没问题，但是今天使用android4.4的时候突然发现不灵了。baidu了一圈，终于解决了。 
下面是解决方案： 
 

private String[] items = new String[] { "图库","拍照" };
		/* 头像名称 */
    
                                
    • 
                                
  • 网页特效大全 jQuery等
                                    ini
JavaScriptjquerycsshtml5ini
                                    
    HTML5和CSS3知识和特效 
asp.net ajax jquery实例 
分享一个下雪的特效 
jQuery倾斜的动画导航菜单 
选美大赛示例 你会选谁 
jQuery实现HTML5时钟 
功能强大的滚动播放插件JQ-Slide 
万圣节快乐！！！ 
向上弹出菜单jQuery插件 
htm5视差动画 
jquery将列表倒转顺序 
推荐一个jQuery分页插件 
jquery animate
    
                                
    • 
                                
  • swift objc_setAssociatedObject block(version1.2 xcode6.4)
                                    啸笑天
version
                                    
      
import UIKit

class LSObjectWrapper: NSObject {
    let value: ((barButton: UIButton?) -> Void)?
    
    init(value: (barButton: UIButton?) -> Void) {
        self.value = value

    
                                
    • 
                                
  • Aegis 默认的 Xfire 绑定方式，将 XML 映射为 POJO
                                    MagicMa_007
javaPOJOxmlAegisxfire
                                    
          Aegis 是一个默认的 Xfire 绑定方式，它将 XML 映射为 POJO, 支持代码先行的开发.你开发服 务类与 POJO,它为你生成 XML schema/wsdl 
XML 和 注解映射概览 
      默认情况下，你的 POJO 类被是基于他们的名字与命名空间被序列化。如果
    
                                
    • 
                                
  • js get max value in (json) Array
                                    qiaolevip
每天进步一点点学习永无止境max纵观千象
                                    
    // Max value in Array
var arr = [1,2,3,5,3,2];Math.max.apply(null, arr); // 5


// Max value in Jaon Array
var arr = [{"x":"8/11/2009","y":0.026572007},{"x"
    
                                
    • 
                                
  • XMLhttpRequest 请求 XML,JSON ,POJO 数据
                                    Luob.
POJOjsonAjaxxmlXMLhttpREquest
                                    
    在使用XMlhttpRequest对象发送请求和响应之前，必须首先使用javaScript对象创建一个XMLHttpRquest对象。 
 

var xmlhttp；
function getXMLHttpRequest(){
  if(window.ActiveXObject){
    xmlhttp:new ActiveXObject("Microsoft.XMLHTTP
    
                                
    • 
                                
  • jquery
                                    wuai
jquery
                                    
    以下防止文档在完全加载之前运行Jquery代码，否则会出现试图隐藏一个不存在的元素、获得未完全加载的图像的大小 等等 
 $(document).ready(function(){ 
 jquery代码; 
 }); 
 
<script type="text/javascript" src="c:/scripts/jquery-1.4.2.min.js&quo
    
                                
    •