冰箱比较冷
冰箱比较冷

多线程进阶—＞JUC并发编程

多线程进阶->JUC并发编程

其实就是java.util.concurrent java.util.concurrent.locks 这些包

业务：普通的线程 Thread

Runnable 没有返回值 效率比callable低 实际开发中都是用callable

java 默认有2个线程 一个main 主线程 一个GC 回收线程

Java 不能开启线程 本地方法调用，底层是C++ ，Java 无法操作硬件

并发&并行

  • 并发（多个线程操作同一个资源）

    ​ 当CPU只有一核，模拟出来多条线程，快速交替

  • 并行（多个人一起行走）

    ​ CPU多核，多个线程可以同时执行

//获取CPU的核数
Runtime.getRuntime().availableProcessors

并发编程的本质：充分利用CPU的资源

线程有几种状态

     //新生
     NEW
     //运行
     RUNNABLE
     //阻塞
     BLOCKED
     //等待，死死的等待
     WAITING
     //超时等待
     TIMED_WAITING
     //终止
     TERMINATED

wait和sleep的区别

1.来自不同的类

​ wait来自Object类

​ sleep来自Thread类

2.关于锁的释放

​ wait会释放锁，sleep不会释放锁

3.使用范围

​ wait必须在同步代码块中才能使用

​ sleep 可以随便在那里都可以使用

Lock锁

多线程进阶—＞JUC并发编程_第1张图片

可重进入锁 读锁 写锁

怎么实现的

多线程进阶—＞JUC并发编程_第2张图片

l.lock(); // 加锁 l.unlock // 解锁

公平锁 和非公平锁

NonfairSync() // 非公平锁

不公平就是因为可以插队（默认就是非公平锁）

fairSync(); //公平锁

就是先来后到

synchronized和Lock的区别

  1. synchronized 是Java关键字，Lock是Java的一个类。
  2. synchronized 可重入锁，不可以中断，非公平锁，Lock可重入锁，可以判断，可以修改非公平锁
  3. synchronized 无法判断获取锁的状态，Lock锁可以获取锁的状态
  4. synchronized 会自动释放锁，Lock必须要手动释放锁！如果不释放就会死锁
  5. synchronized 线程1（获得锁，阻塞），线程2（等待，傻傻的等）Lock锁就不一定会等待下去 Lock.tryLock();
  6. synchronized 适合少量的代码同步问题，Lock适合锁大量的同步代码块

锁是什么，如何判断锁的是谁

生产者和消费者的问题

用while循环而不是用if判断 防止虚假唤醒

多线程进阶—＞JUC并发编程_第3张图片

Condition精准的通知和唤醒线程

condition 同步监视器

8锁现象

如何判断锁的是谁！永远的知道什么锁，锁到底锁的是谁

synchronized锁的对象是调用者

在synchronized前面加了static锁的是class类模板

集合类不安全

List不安全

/**
java.util.ConcurrentModificationException  //并发写入错误
*  ArrayList 之线程不安全
*  解决办法
* 1.List arrayList = new Vector<>();    
	vector的add有 synchronized
* 2.List arrayList = Collections.synchronizedList(new ArrayList<>());
	
* 3.List arrayList =  new CopyOnWriteArrayList<>();  
	JUC解决                         写入时复制的意思
*/

        List<String> arrayList =   new CopyOnWriteArrayList<>();

        for (int i = 0; i < 100; i++) {
     
         new Thread(()->{
     
             arrayList.add(UUID.randomUUID().toString().substring(0,5));
             System.out.println(arrayList);
         },String.valueOf(i)).start();
    }

set不安全

//        Set set = new HashSet<>();
//        Set set = Collections.synchronizedSet(new HashSet<>());
             Set<Object> set = new CopyOnWriteArraySet();
        for (int i = 0; i < 100; i++) {
     
            new Thread(()->{
     
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
 
  
hashSet 底层是什么
 
  
add 就是hashMap的K key 是不能重复的
 
  
 
   
Map不安全
 
  
 
  
  //map是这样用的嘛？ 不是工作中不用HashMap
        //默认等价于什么？ new HasMap<>(16,0.75);
        //Map map= new HashMap<>();
       
        Map<String,String> map = new ConcurrentHashMap<>();
        for (int i = 0; i < 100; i++) {
     
            new Thread(()->{
     
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }

 
  
研究ConcurrentHashMap的原理
 
  
ConcurrentHashMap 是线程安全且高效的HashMap。
 
  
Callable
 
  
​
 
  
public class CallableTest {
     

    public static void main(String[] args) throws ExecutionException, InterruptedException {
     
        //实现Callable 不能直接用  new  Thread().start执行 需要找一个中间的是适配器
        // 那么就需要Runnable 的实现类FutureTask
        MyThread myThread = new MyThread();
        FutureTask futureTask = new FutureTask(myThread);  //适配类的用法
        new  Thread(futureTask).start();
        Object o = futureTask.get();//这个是获取返回值  有可能会阻塞要把它放到最后
        System.out.println(o);
    }
}

class MyThread implements Callable<String>{
     

    @Override
    public String call() throws Exception {
     
        System.out.println("进入call方法");
        return "打印的方法";
    }
}

 
  
总结
 
  
​ FutureTask futureTask = new FutureTask(实现了Callable的类); //适配类的用法
 
  
     
   
  1.  
      	有缓存

     
    2.  
   
  2.  
      	结果可能需要等待  会阻塞

     
    3.  
  
 
  
常用的辅助类
 
  
countDownLatch （减法计数器）
 
  
​
 
  
public class CountDownLatchDemo {
     
    public static void main(String[] args) throws InterruptedException {
     
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i <= 6; i++) {
     
            new Thread(()->{
     
                System.out.println(Thread.currentThread().getName()+"出门");
                countDownLatch.countDown();  //数量-1操作
            },String.valueOf(i)).start();
        }
        // countDownLatch.await();  等待计数器归零的意思 就是等上面的全部执行完毕 在执行下面的操作
         countDownLatch.await();
        System.out.println("------------------------关门-----------------");
    }
}

 
  
 
   
​ 原理
 
   
​ CountDownLatch countDownLatch = new CountDownLatch(6); // 多个数量
 
   
​ countDownLatch.countDown(); 数量-1操作
 
   
​ countDownLatch.await(); 等待计数器归零 才能往下面执行
 
   
​ 每次有线程调用counDown()数量-1，假设计数器变为0，CountDownLatch.await()就会被唤醒，继续执行
 
  
 
  
CyclicBarrier （加法计数器）
 
  
public class CyclicBarrierDemo {
     
    public static void main(String[] args)  {
     
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
     
            System.out.println("召唤神龙");
        });

        for (int i = 0; i <=7; i++) {
     
            int finalI = i;
            new Thread(()->{
     
                System.out.println(Thread.currentThread().getName()+"收集了第"+ finalI+"龙珠");

                try {
     
                    cyclicBarrier.await();  //等待
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
     
                    e.printStackTrace();
                }

            },"唐鸿").start();
        }

    }
}

 
  
​
 
  
Semaphore（信号量 ）
 
  
信号量
 
  
public class SemaphoreDem {
     
    public static void main(String[] args) {
     
        // 线程 数量： 停车位   限流的作用
        Semaphore semaphore = new Semaphore(3);

        for (int i = 1; i <=6; i++) {
     
            new Thread(()->{
     
                try {
     
                    semaphore.acquire();  //acquire() 得到
                    System.out.println(Thread.currentThread().getName()+"抢到了车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开了车位");
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }finally {
     
                    semaphore.release();  //释放
                }
            },String.valueOf(i)).start();
        }
    }
}

 
  
 
   
原理
 
   
​ semaphore.acquire(); 获得，假设如果已经满了，等待被释放位置 -1的操作
 
   
​ semaphore.release(); 释放，会将当前的信号量释放+1，然后唤醒等待的线程
 
   
作用：多个共享资源互斥的使用 ，并发限流，控制最大的线程数
 
  
 
  
读写锁
 
  
readWriteLock
 
  
**
 * 独占锁（写锁） 一次只能被一个线程占有
 * 共享锁（读锁） 多个线程可以同时占有
 * 读-读 可以共存
 * 读-写 不可以共存
 * 写-写 不可以共存
 */
public class RendWritLockDemo {
     
    public static void main(String[] args) {
     
        MyCache myCache = new MyCache();
        for (int i = 0; i < 10; i++) {
     
            int temp = i;
            new Thread(()->{
     
                myCache.put(temp +"", temp +"");
            },String.valueOf(i)).start();
        }
        for (int i = 0; i < 10; i++) {
     
            int temp = i;
            new Thread(()->{
     
                myCache.get(temp +"");
            },String.valueOf(i)).start();
        }
    }
}

class MyCache{
     
    private volatile Map<String,String> map =new HashMap<>();
    //synchronized  和Lock 也能完成操作 但是用写锁 是因为更加细粒度的控制
    //写锁：
         ReentrantReadWriteLock readWriteLock= new ReentrantReadWriteLock();
    public   void put(String k,String v){
     
        readWriteLock.writeLock().lock();
        try {
     
            System.out.println(Thread.currentThread().getName()+"写入"+k);
            map.put(k,v);
            System.out.println(Thread.currentThread().getName()+"写入OK");
        } catch (Exception e) {
     
            e.printStackTrace();
        } finally {
     
            readWriteLock.writeLock().unlock();
        }
    }
        //读锁
    public void get(String k){
     
        readWriteLock.readLock().lock();
        try {
     
            System.out.println(Thread.currentThread().getName()+"读取"+k);
            String put = map.get(k);
            System.out.println(Thread.currentThread().getName()+"读取OK");
        } catch (Exception e) {
     
            e.printStackTrace();
        } finally {
     
            readWriteLock.readLock().unlock();
        }

    }
}

 
  
阻塞队列
 
  
​ FIFO 意思就是先进先出
 多线程进阶—＞JUC并发编程_第4张图片
 
  
多线程进阶—＞JUC并发编程_第5张图片
 
  
 
   
学会使用队列
 
   
添加和移除
 
  
 
  
四组API
 
  
 
    
    
 
     方式 
     抛出异常 
     有返回值值，不抛出异常 
     阻塞等待 
     超时等待 
    
 
    
    
    
 
     添加 
     add 
     offer 
     put 
     offer(“d”, 2, TimeUnit.SECONDS) 
    
 
    
 
     移除 
     remove 
     pooll 
     take 
     pooll(2, TimeUnit.SECONDS) 
    
 
    
 
     检测队首元素 
     element 
     peek 
      
      
    
 
    
  
 
  
 /**
     *抛出异常
     */
    public static void test(){

        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);  //capacity  容量



        System.out.println(arrayBlockingQueue.add("a"));
        System.out.println(arrayBlockingQueue.add("b"));
        System.out.println(arrayBlockingQueue.add("c"));

//        System.out.println(arrayBlockingQueue.add("c"));   //java.lang.IllegalStateException: Queue full   抛出异常说队列已经满了


        System.out.println(  arrayBlockingQueue.element());  //产看队列首位元素
        System.out.println("______________________________");
        System.out.println( arrayBlockingQueue.remove());
        System.out.println( arrayBlockingQueue.remove());
        System.out.println( arrayBlockingQueue.remove());

//        System.out.println( arrayBlockingQueue.remove());    java.util.NoSuchElementException

    }

 
  
public static void test2(){
     
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);  //capacity  容量

        System.out.println( arrayBlockingQueue.offer("a"));
        System.out.println( arrayBlockingQueue.offer("b"));
        System.out.println( arrayBlockingQueue.offer("c"));
//        System.out.println( arrayBlockingQueue.offer("c"));  多加数据不会抛出异常 只会返回一个false


        System.out.println(arrayBlockingQueue.poll());
        System.out.println("----------------------------");
        System.out.println(arrayBlockingQueue.peek());   //peek 检测首元素
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
//        System.out.println(arrayBlockingQueue.poll());  取出多的数据不会抛出异常 会返回一个null
    }

 
  
    public static void test3() throws InterruptedException {
     
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);  //capacity  容量

            arrayBlockingQueue.put("a");
            arrayBlockingQueue.put("b");
            arrayBlockingQueue.put("c");
//            arrayBlockingQueue.put("d");   //队列没有位置了 在等待位置空出 所以一直阻塞

        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take());
//        System.out.println(arrayBlockingQueue.take());  //没有这个元素，一直在阻塞
    }

 
  
    public static void test4() throws InterruptedException {
     
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);  //capacity  容量

        System.out.println(arrayBlockingQueue.offer("a"));
        System.out.println(arrayBlockingQueue.offer("c"));
        System.out.println(arrayBlockingQueue.offer("b"));
//          System.out.println(arrayBlockingQueue.offer("d", 2, TimeUnit.SECONDS));   //超时等待  超过时间就会返回false


        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
//        System.out.println(arrayBlockingQueue.poll( 2, TimeUnit.SECONDS));  // 超时等待  超过时间就会返回null
    }

 
  
SynchronousQueue 同步队列
 
  
/**
 * SynchronousQueue 同步队列
 * 和其他的BlockingQueue不一样，SynchronousQueue 不存储元素
 * put了一个元素，必须从里面先take取出来，否则不能在put进去值
 */
public class synchronizedQueueDemo {
     
    public static void main(String[] args) {
     
        BlockingQueue<String> objectSynchronizedQueue = new SynchronousQueue<>();

         new Thread(()->{
     
             try {
     
                 System.out.println(Thread.currentThread().getName()+"塞入a");
                 objectSynchronizedQueue.put("a");
                 System.out.println(Thread.currentThread().getName()+"塞入b");
                 objectSynchronizedQueue.put("b");
                 System.out.println(Thread.currentThread().getName()+"塞入c");
                 objectSynchronizedQueue.put("c");
             } catch (InterruptedException e) {
     
                 e.printStackTrace();
             }
         },"T").start();

        new Thread(()->{
     
            try {
     
                System.out.println(Thread.currentThread().getName()+"取出"+objectSynchronizedQueue.take());
                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName()+"取出"+objectSynchronizedQueue.take());
                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName()+"取出"+objectSynchronizedQueue.take());
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
        },"B").start();
    }
}

 
  
线程池（重点）
 
  
 
   
池化技术
 
  
 
  
线程池的好处
 
  
     
   
  1.  
    降低资源的消耗
     
    2.  
   
  2.  
    提高响应的速度
     
    3.  
   
  3.  
    方便管理
     
    4.  
  
 
  
线程复用，可以控制最大的并发数，管理线程
 
  
线程池：3大方法
 
  
阿里巴巴 开发手册规定线程池的创建
 
  
多线程进阶—＞JUC并发编程_第6张图片
 
  
/**
 * Executors 工具类 3大创建线程池的方法
 */
public class Demo {
    public static void main(String[] args) {
        ExecutorService threadpool = Executors.newSingleThreadExecutor();  //单个线程
//        ExecutorService threadpool = Executors.newFixedThreadPool(5); //创建一个固定的线程池的大小
//        ExecutorService threadpool = Executors.newCachedThreadPool();// 可伸缩的。遇强则强，预弱则弱

        for (int i = 0; i < 10; i++) {
            //使用了线程池之后，使用线程池来创建线程
            threadpool.execute(()->{
                System.out.println(Thread.currentThread().getName()+"ok");
            });
        }
        //线程池用完一定要关闭线程
        threadpool.shutdown();
    }
}

 
  
7大参数
 
  
​ 源码分析
 
  
public static ExecutorService newSingleThreadExecutor() {
     
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newFixedThreadPool(int nThreads) {
     
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
public static ExecutorService newCachedThreadPool() {
     
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,  // 最大21亿
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

//本质ThreadPoolExecutor
 public ThreadPoolExecutor(	  int corePoolSize,  //核心线程池大小
                              int maximumPoolSize, //最大核心线程池大小
                              long keepAliveTime,  //超时了没有人调用就会释放
                              TimeUnit unit, //超时单位
                              BlockingQueue<Runnable> workQueue,  // 阻塞队列
                              ThreadFactory threadFactory, //线程工厂  创建线程的 一般不用动
                              RejectedExecutionHandler handler //拒绝策略) {
     
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0) 
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

 
  
/**
 * new  ThreadPoolExecutor.AbortPolicy() // 银行满了，还有人进来，不处理这个人的，抛出异常
 * new ThreadPoolExecutor.CallerRunsPolicy()  //哪来的去哪里
 * new ThreadPoolExecutor.DiscardPolicy()  //队列满了，丢掉任务，不会抛出异常
 * new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试去和最早的竞争，也不会抛出异常
 */
public class pool {
     
    public static void main(String[] args) {
     

         //自定义创建线程池 工作中只用ThreadPoolExecutor
        ExecutorService threadPool = new ThreadPoolExecutor(2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());

        try {
     
            //最大承载：Deque + max

            for (int i = 1; i <= 15; i++) {
     
                //使用了线程池之后，就用线程池来创建线程
                threadPool.execute(()->{
     
                    System.out.println(Thread.currentThread().getName()+"ok");
                });
            }
        } catch (Exception e) {
     
            e.printStackTrace();
        } finally {
     
        //线程池用完就的 关闭线程池
            threadPool.shutdown();
        }
    }
}

 
  
4大决绝策略
 
  
     
   
  • new ThreadPoolExecutor.AbortPolicy() // 银行满了，还有人进来，不处理这个人的，抛出异常
    •  
   
  • new ThreadPoolExecutor.CallerRunsPolicy() //哪来的去哪里
    •  
   
  • new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢掉任务，不会抛出异常
    •  
   
  • new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试去和最早的竞争，也不会抛出异常
    •  
  
 
  
​
 
  
小结
 
  
​ 池的最大的数值该如何去设置
 
  
​ 了解IO密集型 和CPU密集型（调优）
 
  
 
   
​ cpu密集型，几核，就是几，可以保持CPU的效率最高
 
   
​ 获取CPU的核数 ：Runtime.getRuntime().availableProcessors
 
  
 
  
 
  
​
 
  
 
   
​ Io 密集型 > 判断你程序中十分耗IO的线程
 
   
​ 程序 15个大型任务 IO十分占用资源
 
  
 
  
四大函数式接口（必需掌握）
 
  
​
 
  
 
   
函数式接口：只有一个方法的接口
 
  
 
  
多线程进阶—＞JUC并发编程_第7张图片
 
  
@FunctionalInterface
public interface Runnable {
     
    public abstract void run();
}
// 泛型、枚举、反射 
// lambda表达式、链式编程、函数式接口、Stream流式计算 
// 超级多FunctionalInterface 
// 简化编程模型，在新版本的框架底层大量应用！ 
// foreach(消费者类的函数式接口)

 
  
@FunctionalInterface 意思的就是函数式接口
 
  
简化编程模型，在新版本的框架底层大量应用
 
  
 
   
Function 函数式接口
 
  
 
  
多线程进阶—＞JUC并发编程_第8张图片
 
  
package com.haust.function;
import java.util.function.Function;
/**
 * Function 函数型接口, 有一个输入参数，有一个输出参数
 * 只要是 函数型接口 可以 用 lambda表达式简化
 */
public class Demo01 {
     
    public static void main(String[] args) {
     
       /*Function function = new 
                                        Function() {
            @Override
            public String apply(String str) {
                return str;
            }
        };*/
        // lambda 表达式简化：
        Function<String,String> function = str->{
     
    return str;};
        System.out.println(function.apply("asd"));
    }
}

 
  
 
   
Predicate 断定型接口 断定型接口：有一个输入参数，返回值只能是 布尔值！
 
  
 
  
多线程进阶—＞JUC并发编程_第9张图片
 
  
package com.haust.function;
import java.util.function.Predicate;
/*
 * 断定型接口：有一个输入参数，返回值只能是 布尔值！
 */
public class Demo02 {
     
    public static void main(String[] args) {
     
        // 判断字符串是否为空
        /*Predicate predicate = new Predicate(){
            @Override
            public boolean test(String str) {
                return str.isEmpty();//true或false
            }
        };*/
        Predicate<String> predicate = 
                            (str)->{
     
    return str.isEmpty(); };
        System.out.println(predicate.test(""));//true
    }
}

 
  
 
   
Consumer 消费型接口
 
  
 
  
多线程进阶—＞JUC并发编程_第10张图片
 
  
package com.haust.function;
import java.util.function.Consumer;
/**
 * Consumer 消费型接口: 只有输入，没有返回值
 */
public class Demo03 {
     
    public static void main(String[] args) {
     
        /*Consumer consumer = new Consumer() {
            @Override
            public void accept(String str) {
                System.out.println(str);
            }
        };*/
        Consumer<String> consumer = 
                                (str)->{
     
    System.out.println(str);};
        consumer.accept("sdadasd");
    }
}

 
  
 
   
Supplier 供给型接口
 
  
 
  
​ 多线程进阶—＞JUC并发编程_第11张图片
 
  
package com.haust.function;
import java.util.function.Supplier;
/**
 * Supplier 供给型接口 没有参数，只有返回值
 */
public class Demo04 {
     
    public static void main(String[] args) {
     
        /*Supplier supplier = new Supplier() {
            @Override
            public Integer get() {
                System.out.println("get()");
                return 1024;
            }
        };*/
        Supplier supplier = ()->{
     
     return 1024; };
        System.out.println(supplier.get());
    }
}

 
  
 
   
其它详细内容可以查看该网址
 
   
https://www.cnblogs.com/Garnett-Boy/p/11151459.html
 
  
 
  
stream流式计算
 
  
 
   
​ 什么是Stream流式计算
 
  
 
  
大数据：存储 + 计算
 
  
集合、MySQL 本质就是存储东西的；
 
  
计算都应该交给流来操作！
 
  
多线程进阶—＞JUC并发编程_第12张图片
 
  
/**
 * 题目要求：
 *  现在有5个用户 筛选：
 *  1.ID必须是偶数
 *  2.年龄必须大于23岁
 *  3.用户名转为大写字母
 *  4，用户名写字母倒着排序
 *  5.只输出一个用户
 */
public class Test {
     


    public static void main(String[] args) {
     
        User a1 = new User(1, "a", 21);
        User a2 = new User(2, "b", 22);
        User a3 = new User(3, "c", 23);
        User a4 = new User(4, "d", 24);
        User a5 = new User(6, "e", 25);
		//集合都是存数据
        List<User> list = Arrays.asList(a1, a2, a3, a4, a5);
        //流用来计算
        list.stream()
                .filter(a->{
     return a.getId()%2==0; })   ///filter  通过里面的判断过滤List的内容
                .filter(a->{
      return a.getAge()>23;})
                .map(a->{
     return a.getName().toUpperCase();})   //map 键值对的映射       toUpperCase()改变大小写
                .sorted( (u1,u2)->{
     return u2.compareTo(u1);})  //  sorted   两个值的排序比较
                .limit(1)
                .forEach(System.out::println);
    }
}

 
  
ForkJoin
 
  
 
   
什么是 ForkJoin
 
  
 
  
ForkJoin在JDK1.7 并行执行任务！提高效率。大数据
 
  
大数据：Map Reduce (把大任务拆分为小任务)
 
  
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OfwuJt7B-1621039866134)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210407201144414.png)]
 
  
​
 
  
ForkJoin 的特点 ：工作窃取
 
  
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LsfTavCw-1621039866134)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210407201151307.png)]
 
  
在这里插入图片描述
 
  
多线程进阶—＞JUC并发编程_第13张图片
 
  
package com.haust.forkjoin;
import java.util.concurrent.RecursiveTask;
/**
 * 求和计算的任务！
 * 3000   6000（ForkJoin）  9000（Stream并行流）
 * // 如何使用 forkjoin
 * // 1、forkjoinPool 通过它来执行
 * // 2、计算任务 forkjoinPool.execute(ForkJoinTask task)
 * // 3. 计算类要继承 RecursiveTask(递归任务，有返回值的)
 */
public class ForkJoinDemo extends RecursiveTask<Long> {
     
    private Long start;  // 1
    private Long end;    // 1990900000
    // 临界值
    private Long temp = 10000L;
    public ForkJoinDemo(Long start, Long end) {
     
        this.start = start;
        this.end = end;
    }
    // 计算方法
    @Override
    protected Long compute() {
     
        if ((end-start)<temp){
     
            Long sum = 0L;
            for (Long i = start; i <= end; i++) {
     
                sum += i;
            }
            return sum;
        }else {
     
     // forkjoin 递归
            long middle = (start + end) / 2; // 中间值
            ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
            task1.fork(); // 拆分任务，把任务压入线程队列
            ForkJoinDemo task2 = new ForkJoinDemo(middle+1, end);
            task2.fork(); // 拆分任务，把任务压入线程队列
            return task1.join() + task2.join();
        }
    }
}

 
  
测试代码：
 
  
package com.haust.forkjoin;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;
/**
 * 同一个任务，别人效率高你几十倍！
 */
public class Test {
     
    public static void main(String[] args) throws ExecutionException, InterruptedException {
     
        // test1(); // 12224
        // test2(); // 10038
        // test3(); // 153
    }
    // 普通程序员
    public static void test1(){
     
        Long sum = 0L;
        long start = System.currentTimeMillis();
        for (Long i = 1L; i <= 10_0000_0000; i++) {
     
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+" 时间："+(end-start));
    }
    // 会使用ForkJoin
    public static void test2() throws ExecutionException, InterruptedException {
     
        long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(
                                                0L, 10_0000_0000L);
        // 提交任务
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);
        Long sum = submit.get();// 获得结果
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+" 时间："+(end-start));
    }
    public static void test3(){
     
        long start = System.currentTimeMillis();
        // Stream并行流 ()  (]
        long sum = LongStream
            .rangeClosed(0L, 10_0000_0000L) // 计算范围(,]
            .parallel() // 并行计算
            .reduce(0, Long::sum); // 输出结果
        long end = System.currentTimeMillis();
        System.out.println("sum="+"时间："+(end-start));
    }
}

 
  
异步回调
 
  
 
   
Future 设计的初衷： 对将来的某个事件的结果进行建模
 
  
 
  
多线程进阶—＞JUC并发编程_第14张图片
 
  
package com.haust.future;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
/**
 * 异步调用： CompletableFuture
 * 异步执行
 * 成功回调
 * 失败回调
 */
public class Demo01 {
     
    public static void main(String[] args) throws ExecutionException, InterruptedException {
     
        // 没有返回值的 runAsync 异步回调
//        CompletableFuture completableFuture = 
//                                    CompletableFuture.runAsync(()->{
     
//            try {
     
//                TimeUnit.SECONDS.sleep(2);
//            } catch (InterruptedException e) {
     
//                e.printStackTrace();
//            }
//            System.out.println(
//                Thread.currentThread().getName()+"runAsync=>Void");
//        });
//
//        System.out.println("1111");
//
//        completableFuture.get(); // 获取阻塞执行结果
        // 有返回值的 supplyAsync 异步回调
        // ajax，成功和失败的回调
        // 返回的是错误信息；
        CompletableFuture<Integer> completableFuture = 
                                CompletableFuture.supplyAsync(()->{
     
            System.out.println(Thread.currentThread().getName()
                                           +"supplyAsync=>Integer");
            int i = 10/0;
            return 1024;
        });
        System.out.println(completableFuture.whenComplete((t, u) -> {
     
            System.out.println("t=>" + t); // 正常的返回结果
            System.out.println("u=>" + u); 
            // 错误信息：
            // java.util.concurrent.CompletionException: 
            // java.lang.ArithmeticException: / by zero
        }).exceptionally((e) -> {
     
            System.out.println(e.getMessage());
            return 233; // 可以获取到错误的返回结果
        }).get());
        /**
         * succee Code 200
         * error Code 404 500
         */
    }
}

 
  
JMM
 
  
 
   
请你谈谈你对 Volatile 的理解
 
  
 
  
Volatile 是 Java 虚拟机提供轻量级的同步机制，类似于synchronized 但是没有其强大。
 
  
1、保证可见性
 
  
2、不保证原子性
 
  
3、防止指令重排
 
  
 
   
什么是JMM
 
  
 
  
JMM ： Java内存模型，不存在的东西，概念！约定！
 
  
关于JMM的一些同步的约定：
 
  
1、线程解锁前，必须把共享变量立刻刷回主存。
 
  
2、线程加锁前，必须读取主存中的最新值到工作内存中！
 
  
3、加锁和解锁是同一把锁。
 
  
线程 工作内存 、主内存
 
  
8 种操作：
 
  
多线程进阶—＞JUC并发编程_第15张图片
 
  
多线程进阶—＞JUC并发编程_第16张图片
 
  
内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和writ操作在某些平台上允许例外）
 
  
     
   
  • lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
    •  
   
  • unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
    •  
   
  • read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
    •  
   
  • load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
    •  
   
  • use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令
    •  
   
  • assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中
    •  
   
  • store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用
    •  
   
  • write （写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中
    •  
  
 
  
JMM 对这八种指令的使用，制定了如下规则：
 
  
     
   
  • 不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
    •  
   
  • 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
    •  
   
  • 不允许一个线程将没有assign的数据从工作内存同步回主内存
    •  
   
  • 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作
    •  
   
  • 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
    •  
   
  • 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
    •  
   
  • 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
    •  
   
  • 对一个变量进行unlock操作之前，必须把此变量同步回主内存
    •  
  
 
  
问题： 程序不知道主内存的值已经被修改过了
 
  
多线程进阶—＞JUC并发编程_第17张图片
 
  
Volatile
 
  
 
   
保证可见性
 
  
 
  
package com.haust.tvolatile;
import java.util.concurrent.TimeUnit;
public class JMMDemo {
     
    // 不加 volatile 程序就会死循环！
    // 加 volatile 可以保证可见性
    private volatile static int num = 0;
    public static void main(String[] args) {
     
     // main
        new Thread(()->{
     
     // 线程 1 对主内存的变化不知道的
            while (num==0){
     
            }
        }).start();
        try {
     
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        num = 1;
        System.out.println(num);
    }
}

 
  
 
   
不保证原子性
 
  
 
  
原子性：不可分割
 
  
线程A在执行任务的时候，不能被打扰的，也不能被分割的，要么同时成功，要么同时失败
 
  
java.util.concurrent.atomic 多线程下保证原子性的包
 
  
import java.util.concurrent.atomic.AtomicInteger;
 
  
package com.haust.tvolatile;
import java.util.concurrent.atomic.AtomicInteger;
// volatile 不保证原子性
public class VDemo02 {
     
    // volatile 不保证原子性
    // 原子类的 Integer
    private volatile static AtomicInteger num = new AtomicInteger();
    public static void add(){
     
        // num++; // 不是一个原子性操作
        num.getAndIncrement(); // AtomicInteger + 1 方法， CAS
    }
    public static void main(String[] args) {
     
        //理论上num结果应该为 2 万
        for (int i = 1; i <= 20; i++) {
     
            new Thread(()->{
     
                for (int j = 0; j < 1000 ; j++) {
     
                    add();
                }
            }).start();
        }
        // 判断只要剩下的线程不大于2个，就说明20个创建的线程已经执行结束
        while (Thread.activeCount()>2){
     
     // Java 默认有 main gc 2个线程
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() 
                                                       + " " + num);
    }
}

 
  
如果不加 lock 和 synchronized ，怎么样保证原子性
 
  
多线程进阶—＞JUC并发编程_第18张图片
 
  
使用原子类，解决原子性问题。
 
  
多线程进阶—＞JUC并发编程_第19张图片
 
  
// volatile 不保证原子性
 // 原子类的 Integer
 private volatile static AtomicInteger num = new AtomicInteger();
 public static void add(){
     
    // num++; // 不是一个原子性操作
    num.getAndIncrement(); // AtomicInteger + 1 方法， CAS
 }

 
  
这些类的底层都直接和操作系统挂钩！在内存中修改值！Unsafe类是一个很特殊的存在！
 
  
 
   
指令重排
 
  
 
  
什么是指令重排？：我们写的程序，计算机并不是按照你写的那样去执行的。
 
  
源代码 —> 编译器优化的重排 —> 指令并行也可能会重排 —> 内存系统也会重排 ——> 执行
 
  
处理器在执行指令重排的时候，会考虑：数据之间的依赖性
 
  
int x = 1; // 1
int y = 2; // 2
x = x + 5; // 3
y = x * x; // 4

 
  
我们所期望的：1234 但是可能执行的时候会变成 2134 或者 1324
 
  
但是不可能是 4123！
 
  
前提：a b x y 这四个值默认都是 0：
 
  
可能造成影响得到不同的结果：
 
  
 
    
    
 
     线程A 
     线程B 
    
 
    
    
    
 
     x = a 
     y = b 
    
 
    
 
     b =1 
     a = 2 
    
 
    
  
 
  
正常的结果：x = 0; y = 0; 但是可能由于指令重排出现以下结果：
 
  
 
    
    
 
     线程A 
     线程B 
    
 
    
    
    
 
     b = 1 
     a = 2 
    
 
    
 
     x = a 
     y = b 
    
 
    
  
 
  
指令重排导致的诡异结果： x = 2; y = 1;
 
  
 
   
非计算机专业
 
  
 
  
volatile 可以避免指令重排：
 
  
内存屏障。CPU指令。作用：
 
  
     
   
  1. 保证特定操作的执行顺序！
    2.  
   
  2. 可以保证某些变量的内存可见性 (利用这些特性volatile 实现了可见性)
    3.  
  
 
  
多线程进阶—＞JUC并发编程_第20张图片
 
  
volatile 是可以保证可见性。不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生！
 
  
volatile 内存屏障在单例模式中使用的最多！
 
  
单列模式
 
  
 
   
动动小脑袋瓜的单列总结
 
   
​ 什么是单列 ， 为什么用到单列模式？
 
   
​ 单列模式就是一个类只有一个实列对象， 为什么用到单例模式 ， 对性能进行的优化，比如连接数据库的类 本来就是一个常需要用的类，经常销毁和创建那么就非常消耗资源，这个类完全是可以重复使用的，那么就可以用单列模式，这样就可以不用消耗资源
 
   
​ 如何实现单例模式
 
   
​ 单例模式有两种写法 一种就是懒汉式 另一种就是饿汉式
 
   
懒汉式顾名思义 就是非常懒 他需要你要调用才去创建对象
 
   
饿汉式就是一上来就直接创建对象
 
   
饿汉式这样的不好 就是假如是一个比较消耗资源的对象 ，假如又没有用到这个对象 ，就比较浪费
 
   
更加合理的就是懒汉式 只有调用的时候才去创建 比较好
 
   
线程安全问题
 
   
懒汉式 线程不安全 饿汉式线程安全
 
   
饿汉式为什么是线程安全的呢 ？ 懒汉式为什么又不是线程安全的呢？
 
   
饿汉式是线程安全的：由于一个类在整个生命周期只会被加载一次，那么这个单例只会创建一个实列，线程每次拿也只拿到这个唯一实列。
 
   
懒汉式不是线程安全的： 因为调用才创建对象 ， 那么多个线程同时调用的话 ，就会造成实例化多次， 可以在方法上加入synchronize，就可以保证线程安全， 但是每次调用方法都排队争取锁影响性能，优化就可以用DCL双重检测模式，通过两个if 判断对象是否被创建来保证线程安全， 最好加一个volatile 防止指令重拍 ， 正确执行路线应该是1 创建一个内存空间 2 实例化对象 3 把对象指到内从空间里， 不加volatile 的话 ，jvm 为了性能可能就是132 然后另外一个线程在实例化对象 这样的话就会多次创建对象，
 
  
 
  
反射的话 还是可以破坏单例模式
 
  
枚举类 就是典型的单列模式，他是不能被反射破坏的
 
  
//懒汉式
class  LHan{
     
  private    LHan(){
     
      System.out.println(Thread.currentThread().getName());
  }

  private volatile static  LHan lhan = null;
    //volatile  可见   不能保证线程安全     原子性   双层检测所模式  DLC
    
  public  static  synchronized  LHan getInstance(){
     
      if (lhan==null){
     
          synchronized (LHan.class){
     
              if (lhan==null) {
     
                  lhan = new LHan();
              }
          }
      }
      return lhan;
  }
}
//饿汉式
class hungry{
     

    //一上来就要私有化构造
    private  hungry(){
     
    }

    private static  final hungry instance =  new hungry();

    public static  hungry getInstance(){
     
        return instance;
    }

 
  
深入理解CAS
 
  
​
 
  
CAS是英文单词Compare And Swap的缩写，翻译过来就是比较并替换。
 
  
CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。
 
  
更新一个变量的时候，只有当变量的预期值A和内存地址V当中的实际值相同时，才会将内存地址V对应的值修改为B。
 
  
CAS是英文单词Compare And Swap的缩写，翻译过来就是比较并替换。
 
  
CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。
 
  
更新一个变量的时候，只有当变量的预期值A和内存地址V当中的实际值相同时，才会将内存地址V对应的值修改为B。
 
  
ABA问题
 
  
使用CAS会造成ABA问题，一个线程a将数值改成了b，接着又改成了a，当另外一个线程用a对比的时候是正确的，认为是没有变化的，其实是已经变化过了，这种过程就叫ABA问题。
 
  
解决：加版本号 version 每次更改都+1
 
  
CAS的缺点
 
  
通过以上，大家都知道CAS虽然很高效解决了原子操作问题，但是CAS仍然存在问题
 
  
     
   
  1. 循环时间长，开销很大：就是如果CAS失效，就会一直进行尝试，当时间过长仍然失败，那么就会给CPU带来很大的开销。
    2.  
   
  2. 只能保证一个共享变量的原子操作：当对一个变量执行操作时，可以使用循环 CAS 的方式来保证原子操作，但对多个变量操作时，CAS 目前无法直接保证操作的原子性。可以这样解决：使用互斥锁来保证原子性、将多个变量封装成对象，通过 AtomicReference 来保证原子性。
    3.  
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(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开发语言sdl2linux
                        
    需求：操作系统为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前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.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
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、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
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、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
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：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）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录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技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以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
    
                    
    • 
                                
  • 312个免费高速HTTP代理IP（能隐藏自己真实IP地址）
                                    yangshangchuan
高速免费superwordHTTP代理
                                    
      
  
124.88.67.20:843
190.36.223.93:8080
117.147.221.38:8123
122.228.92.103:3128
183.247.211.159:8123
124.88.67.35:81
112.18.51.167:8123
218.28.96.39:3128
49.94.160.198:3128
183.20
    
                                
    • 
                                
  • pull解析和json编码
                                    百合不是茶
androidpull解析json
                                    
    n.json文件: 
[{name:java,lan:c++,age:17},{name:android,lan:java,age:8}] 
  
pull.xml文件 
<?xml version="1.0" encoding="utf-8"?> 
<stu> 
    <name>java
    
                                
    • 
                                
  • [能源与矿产]石油与地球生态系统
                                    comsci
能源
                                    
     
      按照苏联的科学界的说法,石油并非是远古的生物残骸的演变产物,而是一种可以由某些特殊地质结构和物理条件生产出来的东西,也就是说,石油是可以自增长的.... 
 
      那么我们做一个猜想: 石油好像是地球的体液,我们地球具有自动产生石油的某种机制,只要我们不过量开采石油,并保护好
    
                                
    • 
                                
  • 类与对象浅谈
                                    沐刃青蛟
java基础
                                    
     
       类，字面理解，便是同一种事物的总称，比如人类，是对世界上所有人的一个总称。而对象，便是类的具体化，实例化，是一个具体事物，比如张飞这个人，就是人类的一个对象。但要注意的是：张飞这个人是对象，而不是张飞，张飞只是他这个人的名字，是他的属性而已。而一个类中包含了属性和方法这两兄弟，他们分别用来描述对象的行为和性质（感觉应该是
    
                                
    • 
                                
  • 新站开始被收录后，我们应该做什么？
                                    IT独行者
PHPseo
                                    
    新站开始被收录后，我们应该做什么？ 
  
      百度终于开始收录自己的网站了，作为站长，你是不是觉得那一刻很有成就感呢，同时，你是不是又很茫然，不知道下一步该做什么了？至少我当初就是这样，在这里和大家一份分享一下新站收录后，我们要做哪些工作。 
      至于如何让百度快速收录自己的网站，可以参考我之前的帖子《新站让百
    
                                
    • 
                                
  • oracle 连接碰到的问题
                                    文强chu
oracle
                                    
    Unable to find a java Virtual Machine－－安装64位版Oracle11gR2后无法启动SQLDeveloper的解决方案 
作者：草根IT网 来源：未知 人气：813标签： 
导读：安装64位版Oracle11gR2后发现启动SQLDeveloper时弹出配置java.exe的路径，找到Oracle自带java.exe后产生的路径“C:\app\用户名\prod
    
                                
    • 
                                
  • Swing中按ctrl键同时移动鼠标拖动组件（类中多借口共享同一数据）
                                    小桔子
java继承swing接口监听
                                    
            都知道java中类只能单继承，但可以实现多个接口，但我发现实现多个接口之后，多个接口却不能共享同一个数据，应用开发中想实现：当用户按着ctrl键时，可以用鼠标点击拖动组件，比如说文本框。 
编写一个监听实现KeyListener,NouseListener,MouseMotionListener三个接口，重写方法。定义一个全局变量boolea
    
                                
    • 
                                
  • linux常用的命令
                                    aichenglong
linux常用命令
                                    
    1 startx切换到图形化界面 
2 man命令:查看帮助信息 
 man 需要查看的命令,man命令提供了大量的帮助信息,一般可以分成4个部分 
 name:对命令的简单说明 
 synopsis:命令的使用格式说明 
 description:命令的详细说明信息 
 options:命令的各项说明 
3 date:显示时间 
 语法：date [OPTION]... [+FORMAT] 
 
    
                                
    • 
                                
  • eclipse内存优化
                                    AILIKES
javaeclipsejvmjdk
                                    
    一 基本说明      在JVM中，总体上分2块内存区,默认空余堆内存小于 40%时，JVM就会增大堆直到-Xmx的最大限制；空余堆内存大于70%时，JVM会减少堆直到-Xms的最小限制。     1)堆内存(Heap memory):堆是运行时数据区域，所有类实例和数组的内存均从此处分配,是Java代码可及的内存，是留给开发人
    
                                
    • 
                                
  • 关键字的使用探讨
                                    百合不是茶
关键字
                                    
    //关键字的使用探讨/*访问关键词private 只能在本类中访问public 只能在本工程中访问protected 只能在包中和子类中访问默认的 只能在包中访问*//*final   类 方法 变量 final 类 不能被继承  final 方法 不能被子类覆盖，但可以继承 final 变量 只能有一次赋值，赋值后不能改变 final 不能用来修饰构造方法*///this()
    
                                
    • 
                                
  • JS中定义对象的几种方式
                                    bijian1013
js
                                    
        1. 基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)： 
<html>
<head>
    <title>基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)</title>
</head>
<script>
    var obj = new Object();
 
    
                                
    • 
                                
  • 表驱动法实例
                                    bijian1013
java表驱动法TDD
                                    
    获得月的天数是典型的直接访问驱动表方式的实例，下面我们来展示一下： 
MonthDaysTest.java 
package com.study.test;

import org.junit.Assert;
import org.junit.Test;

import com.study.MonthDays;

public class MonthDaysTest {

	@T
    
                                
    • 
                                
  • LInux启停重启常用服务器的脚本
                                    bit1129
linux
                                    
    启动，停止和重启常用服务器的Bash脚本，对于每个服务器，需要根据实际的安装路径做相应的修改 
  
#! /bin/bash

Servers=(Apache2, Nginx, Resin, Tomcat, Couchbase, SVN, ActiveMQ, Mongo);
Ops=(Start, Stop, Restart);
currentDir=$(pwd);
echo
    
                                
    • 
                                
  • 【HBase六】REST操作HBase
                                    bit1129
hbase
                                    
    HBase提供了REST风格的服务方便查看HBase集群的信息，以及执行增删改查操作 
  1. 启动和停止HBase REST 服务 1.1 启动REST服务 
前台启动（默认端口号8080） 
[hadoop@hadoop bin]$ ./hbase rest start 
  
后台启动 
hbase-daemon.sh start rest 
  
启动时指定
    
                                
    • 
                                
  • 大话zabbix 3.0设计假设
                                    ronin47

                                    
    What’s new in Zabbix 2.0? 
去年开始使用Zabbix的时候，是1.8.X的版本，今年Zabbix已经跨入了2.0的时代。看了2.0的release notes，和performance相关的有下面几个： 
 
          :: Performance improvements::Trigger related da
    
                                
    • 
                                
  • http错误码大全
                                    byalias
http协议javaweb
                                    
    响应码由三位十进制数字组成，它们出现在由HTTP服务器发送的响应的第一行。 
响应码分五种类型，由它们的第一位数字表示： 
1）1xx：信息，请求收到，继续处理 
2）2xx：成功，行为被成功地接受、理解和采纳 
3）3xx：重定向，为了完成请求，必须进一步执行的动作 
4）4xx：客户端错误，请求包含语法错误或者请求无法实现 
5）5xx：服务器错误，服务器不能实现一种明显无效的请求 
 
 

    
                                
    • 
                                
  • J2EE设计模式-Intercepting Filter
                                    bylijinnan
java设计模式数据结构
                                    
    Intercepting Filter类似于职责链模式 
有两种实现 
其中一种是Filter之间没有联系，全部Filter都存放在FilterChain中，由FilterChain来有序或无序地把把所有Filter调用一遍。没有用到链表这种数据结构。示例如下： 
 
 

package com.ljn.filter.custom;

import java.util.ArrayList;
    
                                
    • 
                                
  • 修改jboss端口
                                    chicony
jboss
                                    
    修改jboss端口 
  
%JBOSS_HOME%\server\{服务实例名}\conf\bindingservice.beans\META-INF\bindings-jboss-beans.xml 
  
中找到 
  
   <!-- The ports-default bindings are obtained by taking the base bindin
    
                                
    • 
                                
  • c++ 用类模版实现数组类
                                    CrazyMizzz
C++
                                    
    最近c++学到数组类，写了代码将他实现，基本具有vector类的功能 
 
 

#include<iostream>
#include<string>
#include<cassert>
using namespace std;
template<class T>
class Array
{
public:
	//构造函数 
	
    
                                
    • 
                                
  • hadoop dfs.datanode.du.reserved 预留空间配置方法
                                    daizj
hadoop预留空间
                                    
    对于datanode配置预留空间的方法 为：在hdfs-site.xml添加如下配置 
 <property> 
    <name>dfs.datanode.du.reserved</name> 
    <value>10737418240</value> 
  
 
    
                                
    • 
                                
  • mysql远程访问的设置
                                    dcj3sjt126com
mysql防火墙
                                    
    第一步: 激活网络设置 你需要编辑mysql配置文件my.cnf. 通常状况，my.cnf放置于在以下目录： /etc/mysql/my.cnf (Debian linux) /etc/my.cnf （Red Hat Linux/Fedora Linux) /var/db/mysql/my.cnf (FreeBSD) 然后用vi编辑my.cnf，修改内容从以下行： [mysqld] 你所需要: 1
    
                                
    • 
                                
  • ios 使用特定的popToViewController返回到相应的Controller
                                    dcj3sjt126com
controller
                                    
    1、取navigationCtroller中的Controllers
NSArray * ctrlArray = self.navigationController.viewControllers;
2、取出后，执行，
[self.navigationController popToViewController:[ctrlArray objectAtIndex:0] animated:YES
    
                                
    • 
                                
  • Linux正则表达式和通配符的区别
                                    eksliang
正则表达式通配符和正则表达式的区别通配符
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/1976579 
 
首先得明白二者是截然不同的 
通配符只能用在shell命令中,用来处理字符串的的匹配。 
判断一个命令是否为bash shell(linux 默认的shell)的内置命令 
 type -t commad  
返回结果含义 
 file  表示为外部命令 
 alias  表示该
    
                                
    • 
                                
  • Ubuntu Mysql Install and CONF
                                    gengzg
Install
                                    
    http://www.navicat.com.cn/download/navicat-for-mysql
    Step1: 下载Navicat ，网址：http://www.navicat.com/en/download/download.html  
      
    Step2：进入下载目录，解压压缩包：tar -zxvf  navicat11_mysql_en.tar.gz  
    
                                
    • 
                                
  • 批处理，删除文件bat
                                    huqiji
windowsdos
                                    
    @echo off
::演示：删除指定路径下指定天数之前（以文件名中包含的日期字符串为准）的文件。
::如果演示结果无误，把del前面的echo去掉，即可实现真正删除。
::本例假设文件名中包含的日期字符串（比如：bak-2009-12-25.log）
rem 指定待删除文件的存放路径
set SrcDir=C:/Test/BatHome
rem 指定天数
set DaysAgo=1
    
                                
    • 
                                
  • 跨浏览器兼容的HTML5视频音频播放器
                                    天梯梦
html5
                                    
    HTML5的video和audio标签是用来在网页中加入视频和音频的标签，在支持html5的浏览器中不需要预先加载Adobe Flash浏览器插件就能轻松快速的播放视频和音频文件。而html5media.js可以在不支持html5的浏览器上使video和audio标签生效。    How to enable <video> and <audio> tags in 
    
                                
    • 
                                
  • Bundle自定义数据传递
                                    hm4123660
androidSerializable自定义数据传递BundleParcelable
                                    
          我们都知道Bundle可能过put****()方法添加各种基本类型的数据，Intent也可以通过putExtras(Bundle)将数据添加进去，然后通过startActivity()跳到下一下Activity的时候就把数据也传到下一个Activity了。如传递一个字符串到下一个Activity 
  
把数据放到Intent
    
                                
    • 
                                
  • C＃：异步编程和线程的使用（.NET 4.5 ）
                                    powertoolsteam
.net线程C#异步编程
                                    
    异步编程和线程处理是并发或并行编程非常重要的功能特征。为了实现异步编程，可使用线程也可以不用。将异步与线程同时讲，将有助于我们更好的理解它们的特征。 
本文中涉及关键知识点 
1. 异步编程 
2. 线程的使用 
3. 基于任务的异步模式 
4. 并行编程 
5. 总结 
 
  异步编程  
 
什么是异步操作？异步操作是指某些操作能够独立运行，不依赖主流程或主其他处理流程。通常情况下，C＃程序
    
                                
    • 
                                
  • spark 查看 job history 日志
                                    Stark_Summer
日志sparkhistoryjob
                                    
    SPARK_HOME/conf 下:  
spark-defaults.conf 增加如下内容 
spark.eventLog.enabled true spark.eventLog.dir hdfs://master:8020/var/log/spark spark.eventLog.compress true  
spark-env.sh 增加如下内容 
export SP
    
                                
    • 
                                
  • SSH框架搭建
                                    wangxiukai2015eye
springHibernatestruts
                                    
    MyEclipse搭建SSH框架 Struts Spring Hibernate 
1、new一个web project。 
2、右键项目，为项目添加Struts支持。 
   选择Struts2 Core Libraries -<MyEclipes-Library> 
     点击Finish。src目录下多了struts
    
                                
    •