public interface UserService {
    public void addUser();
    public void updateUser();
    public void deleteUser();
}

public class UserServiceImpl implements UserService {
    public void addUser() {
        System.out.println("addUser");
    }
    public void updateUser() {
        System.out.println("updateUser");
    }
    public void deleteUser() {
        System.out.println("deleteUser");
    }
}

public class MyAspect {
    public void before() {
        System.out.println("brfore");
    }
    public void after() {
        System.out.println("after");
    }
}

public class MyBeanFactory {
    public static UserService createService() {
        // 1、目标类
        final UserService userService = new UserServiceImpl();
        // 2、切面类
        final MyAspect myAspect = new MyAspect();
        // 3、代理对象
        // 参数1、类加载器
                         当前类.class.getClassLoader()
                        目标类对象.getClass().getClassLoader()
        // 参数2、目标类所实现的所有接口
                        目标类对象.getClass().getInterfaces()
                        new Class[]{接口.class}
        // 参数3、InvocationHandler处理类，采用匿名内部类实现
        UserService proxyService = (UserService) Proxy.newProxyInstance(MyBeanFactory.class.getClassLoader(),
        userService.getClass().getInterfaces(), new InvocationHandler() {
            //参数1proxy、代理对象
            //参数2method、要执行方法的描述对象
            //参数3arg2、方法的实际参数
            public Object invoke(Object proxy, Method method, Object[] arg2) throws Throwable {
                myAspect.before();
                Object obj = method.invoke(userService, arg2);
                myAspect.after();
                return obj;
            }
        });
        return proxyService;
    }
}

@Test
public void fun() {
    UserService userService = MyBeanFactory.createService();
    userService.addUser();
    userService.updateUser();
    userService.deleteUser();
}

public class MyBeanFactory {
    public static UserServiceImpl createService() {
    // 1、目标类
    final UserServiceImpl userService = new UserServiceImpl();
    // 2、切面类
    final MyAspect myAspect = new MyAspect();
    // 3、代理类
    Enhancer enhancer = new Enhancer();
    //设置父类
    enhancer.setSuperclass(userService.getClass());
    /* 设置回调函数 , MethodInterceptor接口 等效 jdk中 InvocationHandler接口
     * intercept() 等效 jdk invoke()
     */
    enhancer.setCallback(new MethodInterceptor() {
        //参数1、代理对象
        //参数2、要执行方法的描述对象(当前)
        //参数3、方法的实际参数
        //参数4、代理类方法的代理
        public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
            myAspect.before();
            //通过反射的方式执行要目标类的方法
            Object obj = arg1.invoke(userService, arg2);
            //执行代理类的父类（目标类）
            arg3.invokeSuper(arg0, arg2);
            myAspect.after();
            return obj;
        }
    });
    //创建代理对象，向上转型
    UserServiceImpl proxyService = (UserServiceImpl) enhancer.create();
    return proxyService;
    }
}

public class MyAspect implements MethodInterceptor
    public Object invoke(MethodInvocation arg0) throws Throwable {
        System.out.println("before");
        Object obj = arg0.proceed();
        System.out.println("after");
        return obj;
    }
}

@Test
public void fun() {
    String xmlPath = "beanfactory/beans.xml";
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
    // 获得代理对象
    UserService userService = (UserService) applicationContext.getBean("proxyService");
    userService.addUser();
    userService.updateUser();
    userService.deleteUser();
}

public class MyAspect {
    //前置通知，在目标类方法执行前执行
    public void before(JoinPoint joinPoint) {
        System.out.println("before");
    }
    //返回通知，在目标类方法执行后执行，可以拿到目标类方法的返回值，如果没有就是null
    public void afterreturning(JoinPoint joinPoint, Object ret) {
        System.out.println("afterreturning" + ret);
    }
    //异常通知，当目标类方法抛出异常时执行，可以拿到异常信息，类似于在catch块里面的方法
    public void throwable(JoinPoint joinPoint, Throwable e) {
        System.out.println("throwable" + " " + e.getMessage());
    }
    //在最后执行
    public void afterafter(JoinPoint joinPoint) {
        System.out.println("afterafter");
    }
    //在方法前后都会执行
    public Object invoke(ProceedingJoinPoint jontPoint) throws Throwable {
        System.out.println("环绕通知-------->前");
        Object obj = jontPoint.proceed();
        System.out.println("环绕通知---------->后");
        return obj;
    }
}

public class MyAspectBefore implements MethodBeforeAdvice {
    public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
        System.out.println("before");
    }
}

public class MyAspectMethod implements MethodInterceptor {
    public Object invoke(MethodInvocation arg0) throws Throwable {
        System.out.println("环绕前");
        Object obj = arg0.proceed();
        System.out.println("环绕后");
        return obj;
    }
}

Map m = new HashMap();m.put("1", "1");
m.put("2", "2");
m.put("3", "3");
m.put("4", "4");
Map m1 = new HashMap();
m1.put("a","a");
m.putAll(m1);

Object o = m.get("1");

m.clear();

boolean b = m.containsKey("1");boolean b1 = m.containsValue("1");

Set keyset = m.keySet();

Collection values = m.values();

Set entryset = m.entrySet();

Map<Integer,Integer> m2 = new TreeMap(new Comparator() {    @Override
    public int compare(Object o1, Object o2) {
        Double a = (Double) o1;
        Double b = (Double) o2;
        return (a > b ? 1 : 0);
    }
});

List l1 = new ArrayList();
l1.add("1");
l1.add(1,"2");
l1.add("3");
l1.add("4");
List l2 = new ArrayList();
l2.add("5");
l2.add("6");
List l3 = new ArrayList();
l3.add("7");
l3.add("8");
l1.addAll(l2);
l1.addAll(1,l3);

Object o = l1.get(1);

l1.clear();

boolean contains = l1.contains("1");
boolean b = l1.containsAll(l3);

boolean empty = l1.isEmpty();

l1.remove(3);
l1.remove("7");

l1.set(1,"a");

l1.sort(new Comparator() {    @Override
    public int compare(Object o1, Object o2) {
        return 0;
    }
});

l1.addFirst("1");
l1.addLast("2");
l1.removeFirst();
l1.removeLast();
l1.getFirst();
l1.getLast();

l1.offer("1");
l1.offerFirst("2");
l1.offerLast("3");

Object peek = l1.peek();
Object o1 = l1.peekFirst();
Object o = l1.peekLast();

Object poll = l1.poll();
Object o2 = l1.pollFirst();
Object o3 = l1.pollLast();

HashSet set = new HashSet();set.add("1");
set.add("2");
set.add("3");
set.add("4");

boolean contains = set.contains("1");

boolean remove = set.remove("1");

boolean empty = set.isEmpty();

int size = set.size();

set.clear();

TreeSet t = new TreeSet(new Comparator() {
    @Override    public int compare(Object o1, Object o2) {
        return 0;    }
});

public E next() {
    checkForComodification();
    int i = cursor;
    if (i >= size)
        throw new NoSuchElementException();
    Object[] elementData = ArrayList.this.elementData;
    if (i >= elementData.length)
        throw new ConcurrentModificationException();
    cursor = i + 1;
    return (E) elementData[lastRet = i];
}

final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

public Iterator<E> iterator() {
    return new Itr();
}

/**
 * An optimized version of AbstractList.Itr
 */
private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;
    Itr() {}

public E remove(int index) {
	rangeCheck(index);
	modCount++;
	E oldValue = elementData(index);
	int numMoved = size - index - 1;
	if (numMoved > 0)
		System.arraycopy(elementData, index+1, elementData, index,
					 numMoved);
	elementData[--size] = null; // clear to let GC do its work
	return oldValue;
}

public boolean add(E e) {
	ensureCapacityInternal(size + 1);  // Increments modCount!!
	elementData[size++] = e;
	return true;
}

private void ensureCapacityInternal(int minCapacity) {
	ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private void ensureExplicitCapacity(int minCapacity) {
	modCount++;
	// overflow-conscious code
	if (minCapacity - elementData.length > 0)
		grow(minCapacity);
}

public void remove() {
	if (lastRet < 0)
		throw new IllegalStateException();
	checkForComodification();

	try {
		ArrayList.this.remove(lastRet);
		cursor = lastRet;
		lastRet = -1;
		expectedModCount = modCount;
	} catch (IndexOutOfBoundsException ex) {
		throw new ConcurrentModificationException();
	}
}

public boolean hasNext() {
	return cursor != SubList.this.size;
}

package com.company;
class NumberHolder {
    private int number;
    public synchronized void increase() {
        if (0 != number) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 能执行到这里说明已经被唤醒
        // 并且number为0
        number++;
        System.out.print(number+"-");
        // 通知在等待的线程
        notify();
    }
    public synchronized void decrease() {
        if (0 == number) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 能执行到这里说明已经被唤醒
        // 并且number不为0
        number--;
        System.out.print(number+"-");
        notify();
    }
}
class IncreaseThread extends Thread {
    private NumberHolder numberHolder;
    public IncreaseThread(NumberHolder numberHolder) {
        this.numberHolder = numberHolder;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; ++i) {
            // 进行一定的延时
            try {
                Thread.sleep((long) Math.random() * 10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 进行增加操作
            numberHolder.increase();
        }
    }
}
class DecreaseThread extends Thread {
    private NumberHolder numberHolder;
    public DecreaseThread(NumberHolder numberHolder) {
        this.numberHolder = numberHolder;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; ++i) {
            // 进行一定的延时
            try {
                Thread.sleep((long) Math.random() * 10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 进行减少操作
            numberHolder.decrease();
        }
    }
}
public class Main {
    public static void main(String[] args) throws InterruptedException {
        NumberHolder numberHolder = new NumberHolder();
        Thread t1 = new IncreaseThread(numberHolder);
        Thread t2 = new DecreaseThread(numberHolder);
        // Thread t3 = new DecreaseThread(numberHolder);
        // Thread t4 = new DecreaseThread(numberHolder);
        t1.start();
        t2.start();
        // t3.start();
        // t4.start();
    }
}

public class myThread {
    public static void main(String[] args) {
        myThread1 m1 = new myThread1("你好1");
        m1.start();
        myThread1 m2 = new myThread1("你好2");
        m2.start();
    }
}
//继承Thread类
class myThread1 extends Thread {
    private int tickets = 100;
    private String name;
    public myThread1(String name) {
        this.name = name;
    }
    //doSomeThing
    @Override
    public void run() {
        while (this.tickets > 0) {
            System.out.println(this.name + "--------" + this.tickets--);
        }
    }
}

public class myThreadtwo {
    private static int aa = 10;
    public static void main(String[] args) {
        mythread1 m1 = new mythread1(aa);
        Thread t1 = new Thread(m1,"第一个");
        Thread t2 = new Thread(m1,"第二个");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(aa);
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }
}
//实现Runnable类
class mythread1 implements Runnable {
    private int tickets = 10;
    public mythread1(int t) {
        this.tickets = t;
    }
    //doSomeThing
    @Override
    public void run() {
//        synchronized (this) {
            while (this.tickets > 0) {
                System.out.println(Thread.currentThread().getName() + "--------" + this.tickets--);
            }
            System.out.println(this);
//        }
    }
}

public class myThreadThree {
    private static int aa = 10;
    public static void main(String[] args) {
        myThreadnew m1 = new myThreadnew(aa);
        FutureTask future = new FutureTask(m1);
        Thread t1 = new Thread(future,"第一个");
        Thread t2 = new Thread(future,"第二个");
        Thread t3 = new Thread(new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception {
                return null;
            }
        }));
        t1.start();
        t2.start();
        t3.start();
        try {
            future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
//实现Callable类
class myThreadnew implements Callable{
    private int tickets = 10;
    public myThreadnew(int t) {
        this.tickets = t;
    }
    //doSomeThing
    @Override
    public Object call() throws Exception {
        while (this.tickets > 0) {
            System.out.println(Thread.currentThread().getName() + "--------" + this.tickets--);
        }
        System.out.println(this);
        return null;
    }
}