成长中的小boy
成长中的小boy

多线程 详解(掌握这篇就够了)

文章目录

  • 一、线程简介
    • Process和Thread
    • 程序 进程 线程
    • 核心概念
  • 二、线程创建(重点)
    • 1、继承Thread
    • 2、实现Runnable接口(推荐使用)
    • 3、 实现Callable接口
    • 4、龟兔赛跑
    • 5、小结
      • 继承Thread类
      • 实现Runnable接口
    • 静态代理
      • Thread静态代理底层剖析
    • 动态代理
      • newProxyInstance解析
      • 动态代理多个接口
      • 动态代理的秘密
      • 代理的作用
      • 总结
    • lambda表达式
  • 三、线程状态（五大状态）
    • 状态概念
    • 线程方法
    • 停止线程（使用标志位）
    • 线程休眠（sleep）
      • 模拟网络延迟
      • sleep获取当前时间
    • 线程礼让（yield）
    • 线程插队（join）
    • 线程状态观测
    • 线程优先级
    • 守护(daemon)线程
  • 四、线程同步（重点）
    • 并发和并行
    • 线程同步
    • 同步方法
    • 同步方法弊端
    • 同步块
    • 代码示例
      • 卖票
      • 取钱（ACID补充）
      • ArrayList
      • CopyOnWriteArrayList 线程安全
      • 序列化和反序列化（Serializable）
    • 死锁
      • 代码示例
      • 死锁避免方法
    • Lock（锁）
    • synchronized 与 Lock 的对比
  • 线程协作
    • 线程通信
    • 生产者消费者问题
      • 管程法
      • 信号灯法
      • 线程池法

一、线程简介

普通线程和多线程的应用
多线程 详解(掌握这篇就够了)_第1张图片

Process和Thread

  • 说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运 行的含义，是一个静态的概念。
  • 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
  • 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的的单位

注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能 执行一个代码，因为切换的很快，所以就有同时执行的错局。注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错局。

程序 进程 线程

在操作系统中运行的程序就是我们所说的进程，比如我们电脑的应用 网易云、百度、微信等这些都是一个进程。

进程中实现的不同功能，我们称之为线程，比如一个视频中我们能够同时看到弹幕，听到声音，看图像这都可以叫做不同的线程

三者之间的关系：程序中包含多个进程 进程中同时包含多个线程（且至少有一个线程为主线程）

核心概念

  • 线程就是独立的执行路径；
  • 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
  • main() 称之为主线程，为系统的入口，用于执行整个程序；
  • 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与
  • 操作系统紧密相关的，先后顺序是不能认为的干预的。
  • 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
  • 线程会带来额外的开销，如cpu调度时间，并发控制开销。
  • 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

二、线程创建(重点)

  • 继承Thread (重点)
  • 实现Callable接口 (重点)
  • 实现Callable接口 (了解)

1、继承Thread

  • 自定义线程类继承Thread类
  • 重写run()方法，编写线程执行体
  • 创建线程对象，调用start()方法启动线程
public class Thread1 {
     

   //线程开启不一定执行，由cpu进行调度,
   public static void main(String[] args) {
     

      MyThread myThread = new MyThread();
      myThread.start();

      try {
     
         Thread.sleep(2);
      } catch (InterruptedException e) {
     
         e.printStackTrace();
      }

      for (int i=0;i<200;i++){
     
         System.out.println("我是主线程"+i);
      }
   }
}
//主线程 子线程的执行顺序 由cpu进行调度，cpu执行速度很快,一般先执行主线程
class MyThread extends Thread{
     

   @Override
   public void run() {
     
      for (int i=0;i<50;i++){
     
         System.out.println("我是子线程"+i);
      }
   }
}

2、实现Runnable接口(推荐使用)

  • 定义MyRunnable类实现Runnable接口
  • 实现run()方法，编写线程执行体
  • 创建线程对象，调用start()方法启动线程
//多线程抢票
public class ticket {
     

   public static void main(String[] args) {
     

      MyTicket myTicket = new MyTicket();

      new Thread(myTicket,"A").start();
      new Thread(myTicket,"B").start();
   }
}


class MyTicket implements Runnable {
     


   public int tickets = 100;

   @Override
   public void run() {
     
      while (tickets>0) {
     
         System.out.println(Thread.currentThread().getName() + "抢到了第" + tickets-- + "张票");
      }
   }
}

3、 实现Callable接口

  1. 实现Callable接口，需要返回值类型
  2. 重写call方法，需要抛出异常
  3. 创建目标对象
  4. 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
  5. 提交执行：Future result1 = ser.submit(t1);
  6. 获取结果：boolean r1 = result1.get()
  7. 关闭服务：ser.shutdownNow();
//多线程下载图片
//实现图片的下载要先导入common-io的jar包
public class TestCallable {
     
   public static void main(String[] args) throws ExecutionException, InterruptedException {
     

      //执行线程
      downThread t1 = new downThread("https://img-bss.csdnimg.cn/1615183593661.png","a.jpg");
      downThread t2= new downThread("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fa0.att.hudong.com%2F30%2F29%2F01300000201438121627296084016.jpg&refer=http%3A%2F%2Fa0.att.hudong.com&app=2002&size=f9999," +
            "10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1618125226&t=206ef43a6621700711f384e286ee4220","b.jpg");

      //创建执行服务 开启线程池
      ExecutorService ser= Executors.newFixedThreadPool(2);

      //提交执行
      Future<Boolean> future1=ser.submit(t1);
      Future<Boolean> future2=ser.submit(t2);

      //获取结果
      boolean flag1= future1.get();
      boolean flag2= future2.get();
      System.out.println(flag1);
      System.out.println(flag2);

      //关闭服务
      ser.shutdownNow();

   }
}

class downThread implements Callable<Boolean> {
     

   public String url;
   public String name;

   public downThread(String url,String name){
     
      this.url=url;
      this.name=name;
   }

   @Override
   public Boolean call(){
     
      //执行体
      webDownLoad webDownLoad = new webDownLoad();
      webDownLoad.photoDown(url,name);
      System.out.println(name+"图片下载完成");
      return true;
   }
}

class webDownLoad {
     

   //定义下载图片的方法
   public void photoDown(String url, String name) {
     
      	//借助封装的类 FileUtils 将该路径的图片 拷贝到指定文件
      String file="G:\\idea\\bilibili\\kuang\\Thread\\src\\com\\zz\\demo01";
      try {
     
         //将网络路径 url 的资源下载到指定的文件夹中去，并命名为name
         FileUtils.copyURLToFile(new URL(url), new File(file,name));

      } catch (IOException e) {
     
         e.printStackTrace();
      }
   }
}

4、龟兔赛跑

1.首先来个赛道距离，然后要离终点越来越近

  1. 判断比赛是否结束
  2. 打印出胜利者
  3. 龟兔赛跑开始
  4. 故事中是乌龟赢的，兔子需要睡觉，所以我们来模拟兔子睡觉
  5. 终于，乌龟赢得比赛
//龟兔赛跑 实例
/**
 * 1 自定义一个boolean方法 决出胜利者
 * 2 将逻辑代码放入 线程体run方法中
 * 3 开启乌龟、兔子两条线程
 */
public class game {
     
   public static void main(String[] args) {
     

      Race race = new Race();

      new Thread(race, "兔子").start();
      new Thread(race, "乌龟").start();
   }
}

class Race implements Runnable {
     

   public int steps = 10000;
   public String winner;

   @Override
   public void run() {
     

      while (steps > 0) {
     

         if (Thread.currentThread().getName().equals("兔子")) {
     
            try {
     
               Thread.sleep(1);
            } catch (InterruptedException e) {
     
               e.printStackTrace();
            }
         }

         boolean flag = gameover(steps);
         if (flag) {
     
            break;
         } else {
     
            //没到终点就继续跑
            System.out.println(Thread.currentThread().getName() + "跑了" + steps-- + "步");
         }
      }
   }
   //决出胜利者=
   public boolean gameover(int step) {
     
      if (winner != null) {
     
         //已经产生了胜利者
         return true;
      }

      if (step <= 1) {
     
         winner = Thread.currentThread().getName();
         System.out.println(winner + "赢了");
         return true;
      }
      return false;
   }
}

5、小结

继承Thread类

  • 子类继承Thread类具备多线程能力
  • 启动线程：子类对象. start()
  • 不建议使用：避免OOP单继承局限性

实现Runnable接口

  • 实现接口Runnable具有多线程能力
  • 启动线程：传入目标对象+Thread对象.start()
  • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

多线程 详解(掌握这篇就够了)_第2张图片

静态代理

代理模式在我们生活中很常见，例如 按理说我们在生活中购物的时候，可以直接从工厂进行购物，但是我们生活中常常不是这样，一般都是厂家委托给供销商（超市）进行销售，而我们不直接和厂商进行关联，这其中就引用了静态代理的思想，厂家相当于真实角色，而超市相当于代理角色，厂家产品相当于接口，我们作为购买者 客户端。
其实代理角色的作用就是，辅助真实角色完成一些事情，在真实角色业务的前提下，还可以增加其他的业务，一起帮助真实角色共同完成。后面AOP切面编程就是运用了该思想。
多线程 详解(掌握这篇就够了)_第3张图片

这是常见代理模式常见的 UML 示意图。

下面通过模拟婚庆公司，来实现静态代理 我们真实角色，婚庆公司代理角色 结婚事件为接口

/**
 * @Author zz
 * @Date 2021/3/12 15:27
 */

//静态代理 多线程也是静态代理原理实现
public class Proxy {
     

   public static void main(String[] args) {
     

        //真实角色
		you you = new you();

		//代理角色
		Marry marry = new WeddingCompany(you);

		//代理角色 帮助真实角色实现
		marry.marride();
   }
}

interface Marry{
     
   //定义一个结婚接口
   void marride();
}

//真实角色 结婚
class you implements Marry{
     

   @Override
   public void marride() {
     
      System.out.println("xxx结婚了");
   }
}

//婚庆公司 帮助我实现结婚 婚庆公司可以在结婚前后增加所需要的业务
class WeddingCompany implements Marry{
     

   //引入真实角色
   public Marry target;

   public WeddingCompany(Marry target){
     
      this.target=target;
   }

   @Override
   public void marride() {
     
      before();
      target.marride();
      after();
   }

   private void before() {
     
      System.out.println("结婚前，进行场地的布置");
   }

   private void after() {
     
      System.out.println("结婚后，收拾东西回公司");
   }
}

结果：
结婚前
xxx结婚了
结婚后

现在可以看到，代理模式可以在不修改被代理对象you的基础上，通过扩展代理类，进行一些功能的附加与增强。值得注意的是，代理类和被代理类应该共同实现一个接口marride()，或者是共同继承某个类。

上面介绍的是静态代理的内容，为什么叫做静态呢？因为它的类型是事先预定好的，比如上面代码中的 WeddingCompany代理角色这个类。下面要介绍的内容就是动态代理。

Thread静态代理底层剖析

理解完了静态代理，我们应用静态代理的思想来分析多线程

Thread底层也是通过静态代理原理实现的，通过我们开启子线程来定义真实角色，Thread为代理角色，Runnable为要实现得到接口，run为接口中的方法

Runnable接口，以及里面的run方法

public interface Runnable {
     
    /**
     * When an object implementing interface Runnable is used
     * to create a thread, starting the thread causes the object's
     * run method to be called in that separately executing
     * thread.
     * 

     * The general contract of the method run is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

我们在开启子线程的过程中，其实就是定义一个真实角色MyThread实现了一个Runnable接口，并重写了Runnable接口里面的run()方法 真实角色

class MyThread implements Runnable{
     
   @Override
   public void run() {
     
     System.out.println(“我是子线程，同时是真实角色”);
   }
}

这里代理对象为Thread类，我们通过Thread源码，分析得Thread也是实现了Runnable接口，并实现了run方法 代理角色

 * @author  unascribed
 * @see     Runnable
 * @see     Runtime#exit(int)
 * @see     #run()
 * @see     #stop()
 * @since   JDK1.0
 */
//这里代理角色Thread也实现了Runnable接口
public
class Thread implements Runnable {
     
    /* Make sure registerNatives is the first thing  does. */
    private static native void registerNatives();
    static {
     
        registerNatives();
    }
//代理对象中的 构造器
 public Thread(Runnable target, String name) {
     
        init(null, target, name, 0);
}

代理真实对象实现方法

public static void main(String[] args) {
     

   //真实角色
   Runnable myRunnable = new MyRunnable();

   //代理角色
   Thread thread = new Thread(myRunnable,"A");
   //实现的方法
   thread.start();
   //thread.run();
}

示例代码

public class TestRunnable {
     
   public static void main(String[] args) {
     

      //真实角色
      Runnable myRunnable = new MyRunnable();

      //代理角色
      Thread thread = new Thread(myRunnable,"A");
      //实现的方法
      thread.start();
      //thread.run();
   }
}
class MyRunnable implements Runnable{
     
   @Override
   public void run() {
     
      System.out.println("我是子线程");
   }
}

动态代理

既然是代理，那么它与静态代理的功能与目的是没有区别的，唯一有区别的就是动态与静态的差别。

前面我们知道静态代理的实现是要我们手动创建代理对象WeddingCompany实现Marry接口，那么动态代理所体现的不同就是我们可以让程序在运行的时候自动在内存中创建一个实现Marry接口的代理类，而不用手动去定义WeddingCompany这个代理类，这就是它被称为动态代理的原因。

可能概念比较抽象，那么我们通过代码来进行实现

在以上静态代理的场景下来实现动态代理

/**
 * @Author zz
 * @Date 2021/3/12 18:45
 */
public class ProxyDongTai {
     

	public static void main(String[] args) {
     
		//真实角色
		MarryDT realRole = new youDT();

		//代理角色 注意这里不是实现接口InvocationHandler
		WeddingCompanyDT proxy=new WeddingCompanyDT(realRole);

		//生成代理类
		//MarryDT proxyRole = (MarryDT) Proxy.newProxyInstance(youDT.class.getClassLoader(), realRole.getClass().getInterfaces(), proxy);
		
		//调用方法 生成代理类
		MarryDT proxyRole = (MarryDT)proxy.getProxy();
		
		proxyRole.marride();


	}
}

interface MarryDT {
     
	//定义一个结婚接口
	void marride();
}

//真实角色 结婚
class youDT implements MarryDT {
     

	@Override
	public void marride() {
     
		System.out.println("xxx结婚了");
	}
}

//动态代理类 要实现InvocationHandler接口
class WeddingCompanyDT implements InvocationHandler {
     

	//引入接口 真实对象
	public MarryDT target;

	public WeddingCompanyDT(MarryDT target) {
     
		this.target = target;
	}

	//生成得到的代理类
    // loader 自然是类加载器
    // interfaces 代码要用来代理的接口
    // h是一个 InvocationHandler 对象

	public Object getProxy(){
     
		return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
	}


	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     

		before();
		method.invoke(target,args);
		after();

		return null;
	}

	private void after() {
     
		System.out.println("结婚后");
	}

	private void before() {
     
		System.out.println("结婚前");
	}
}

结果：
结婚前
xxx结婚了
结婚后

newProxyInstance解析

动态代码涉及了一个非常重要的类 Proxy。正是通过 Proxy 的静态方法 newProxyInstance 才会动态创建代理。

Proxy

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

下面讲解它的 3 个参数意义。

  • loader 自然是类加载器
  • interfaces 代码要用来代理的接口
  • h 一个 InvocationHandler 对象

InvocationHandler

InvocationHandler 是一个接口，官方文档解释说，每个代理的实例都有一个与之关联的 InvocationHandler 实现类，如果代理的方法被调用，那么代理便会通知和转发给内部的 InvocationHandler 实现类，由它决定处理。

public interface InvocationHandler {
     

    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

InvocationHandler 内部只是一个 invoke() 方法，正是这个方法决定了怎么样处理代理传递过来的方法调用。

  • proxy 代理对象
  • method 代理对象调用的方法
  • args 调用的方法中的参数

因为，Proxy 动态产生的代理会调用 InvocationHandler 实现类，所以 InvocationHandler 是实际执行者。

//动态代理类 要实现InvocationHandler接口
class WeddingCompanyDT implements InvocationHandler {
     

   //引入接口 真实对象
   public MarryDT target;

   public WeddingCompanyDT(MarryDT target) {
     
      this.target = target;
   }

   //生成得到的代理类
   public Object getProxy(){
     
      //ClassLoader loader,
      //Class[] interfaces
      //InvocationHandler h
      return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
   }
   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     
      before();
      method.invoke(target,args);
      after();
      return null;
   }

   private void after() {
     
      System.out.println("结婚后");
   }

   private void before() {
     
      System.out.println("结婚前");
   }
}

动态代理多个接口

以上实例体现的是一个人结婚并且由婚礼公司提供婚事的安排，那如果有多个人结婚那 那要怎么实现那

这里我们只需要写多个接口，就可以模拟多个人结婚的实例，其中都是由婚庆公司（动态代理类）来处理婚事

也可以在一个结婚接口中，定义多个方法来实现

/**
 * @Author zz
 * @Date 2021/3/12 18:45
 */
public class ProxyDongTai {
     
	public static void main(String[] args) {
     
		//你的 真实角色
		MarryDT realRoleYou = new youDT();

		//他的真实角色
		MarryTa realRoleTa=new TaDT();

		//代理角色 注意这里不是实现接口InvocationHandler
		WeddingCompanyDT proxyYou=new WeddingCompanyDT(realRoleYou);

		WeddingCompanyDT proxyTa=new WeddingCompanyDT(realRoleTa);

		//生成代理类
//		MarryDT proxyRoleYou =(MarryDT)Proxy.newProxyInstance(youDT.class.getClassLoader(), realRoleYou.getClass().getInterfaces(), proxyYou);
//		MarryTa proxyRoleTa =(MarryTa)Proxy.newProxyInstance(TaDT.class.getClassLoader(), realRoleTa.getClass().getInterfaces(), proxyTa);

		//调用方法 生成代理类
		MarryDT proxyRoleYou = (MarryDT)proxyYou.getProxy();

		MarryTa proxyRoleTa = (MarryTa)proxyTa.getProxy();


		System.out.println("实现自动代理多个接口");
		System.out.println();
		proxyRoleYou.marride();
		System.out.println("-----------");
		proxyRoleTa.marriedTa();

	}
}


interface MarryDT {
     
   //定义一个结婚接口
   void marride();
}

interface MarryTa{
     
   //定义一个他结婚的接口
   void marriedTa();
}

class TaDT implements MarryTa{
     

   @Override
   public void marriedTa() {
     
      System.out.println("他也结婚了");
   }
}

//真实角色 结婚
class youDT implements MarryDT {
     

   @Override
   public void marride() {
     
      System.out.println("你结婚了");
   }
}

//动态代理类 要实现InvocationHandler接口
class WeddingCompanyDT implements InvocationHandler {
     

   //引入接口 真实对象
// public MarryDT target;
// public MarryTa ta;

// public WeddingCompanyDT(MarryDT target) {
     
//    this.target = target;
// }
//
// public WeddingCompanyDT(MarryTa ta) {
     
//    this.ta = ta;
// }

   /**
    * 这里定义真实角色，我们一般使用Object类，若后面可能要引入多个接口，
    * 这样在getProxy()方法以及invoke()方法中，不会出现多个不同的接口不能同时进行代理的情况
    */
   public Object realTarget;


   public WeddingCompanyDT(Object realTarget){
     
      this.realTarget=realTarget;
   }

   //生成得到的代理类
   public Object getProxy(){
     
      //ClassLoader loader,
      //Class[] interfaces
      //InvocationHandler h
      return Proxy.newProxyInstance(this.getClass().getClassLoader(),realTarget.getClass().getInterfaces(),this);
   }


   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     

      before();
      method.invoke(realTarget,args);
      after();

      return null;
   }

   private void after() {
     
      System.out.println("结婚后");
   }

   private void before() {
     
      System.out.println("结婚前");
   }
}

结果：
实现自动代理多个接口

结婚前
你结婚了
结婚后
-----------
结婚前
他也结婚了
结婚后

这里要注意下，若程序中出现多个接口代理的情况下，我们要把在代理类中引入真实角色的类型改为Object类型

/**
 * 这里定义真实角色，我们一般使用Object类，若后面可能要引入多个接口，
 * 这样在getProxy()方法以及invoke()方法中，不会出现多个不同的接口不能同时进行代理的情况
 */
public Object realTarget;

public WeddingCompanyDT(Object realTarget){
     
   this.realTarget=realTarget;
}

其中也可以在主方法中，生成代理类newProxyInstance来实现这样如果多个接口都实现的话，代码就比较冗余

public static void main(String[] args) {
     
		//你的 真实角色
		MarryDT realRoleYou = new youDT();

		//他的真实角色
		MarryTa realRoleTa=new TaDT();

		//代理角色 注意这里不是实现接口InvocationHandler
		WeddingCompanyDT proxyYou=new WeddingCompanyDT(realRoleYou);

		WeddingCompanyDT proxyTa=new WeddingCompanyDT(realRoleTa);

		//生成代理类
		MarryDT proxyRoleYou =(MarryDT)Proxy.newProxyInstance(youDT.class.getClassLoader(), realRoleYou.getClass().getInterfaces(), proxyYou);
		MarryTa proxyRoleTa =(MarryTa)Proxy.newProxyInstance(TaDT.class.getClassLoader(), realRoleTa.getClass().getInterfaces(), proxyTa);

		//调用方法 生成代理类
//		MarryDT proxyRoleYou = (MarryDT)proxyYou.getProxy();
//
//		MarryTa proxyRoleTa = (MarryTa)proxyTa.getProxy();


		System.out.println("实现自动代理多个接口");
		System.out.println();
		proxyRoleYou.marride();
		System.out.println("-----------");
		proxyRoleTa.marriedTa();

	}

动态代理的秘密

我们想下为什么 Proxy 能够动态产生不同接口类型的代理，我的猜测是肯定通过传入进去的接口然后通过反射动态生成了一个接口实例。
比如 MarryDT是一个接口，那么 Proxy.newProxyInstance() 内部肯定会有

new MarryDT();

这样相同作用的代码，不过它是通过反射机制创建的。那么事实是不是这样子呢？直接查看它们的源码好了。需要说明的是，我当前查看的源码是 1.8 版本。

@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
     
    Objects.requireNonNull(h);

    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
     
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    /*
     * Look up or generate the designated proxy class.
     */
     //这里newProxyInstance 的确创建了一个实例，我们点进去
    Class<?> cl = getProxyClass0(loader, intfs);

    /*
     * Invoke its constructor with the designated invocation handler.
     */
    try {
     
        if (sm != null) {
     
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }

        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) {
     
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
     
                public Void run() {
     
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        return cons.newInstance(new Object[]{
     h});
    } catch (IllegalAccessException|InstantiationException e) {
     
        throw new InternalError(e.toString(), e);
    } catch (InvocationTargetException e) {
     
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
     
            throw (RuntimeException) t;
        } else {
     
            throw new InternalError(t.toString(), t);
        }
    } catch (NoSuchMethodException e) {
     
        throw new InternalError(e.toString(), e);
    }
}

newProxyInstance 的确创建了一个实例，它是通过 cl 这个 Class 文件的构造方法反射生成。cl 由 getProxyClass0() 方法获取。

private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
     
    if (interfaces.length > 65535) {
     
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // If the proxy class defined by the given loader implementing
    // the given interfaces exists, this will simply return the cached copy;
    // otherwise, it will create the proxy class via the ProxyClassFactory
    //从注释我们可以得到说，如果由实现给定接口的给定加载器定义的代理类存在，则只会返回缓存的副本;否则，它将通过ProxyClassFactory创建代理类
    //我们点进去ProxyClassFactory这个类
    return proxyClassCache.get(loader, interfaces);
}

直接通过缓存获取，如果获取不到，注释说会通过 ProxyClassFactory 生成。

/**
 * A factory function that generates, defines and returns the proxy class given
 * the ClassLoader and array of interfaces.
 */
private static final class ProxyClassFactory
    implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
     
    // prefix for all proxy class names
    private static final String proxyClassNamePrefix = "$Proxy";

    // next number to use for generation of unique proxy class names
    private static final AtomicLong nextUniqueNumber = new AtomicLong();

    @Override
    public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
     

        Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
        for (Class<?> intf : interfaces) {
     
            /*
             * Verify that the class loader resolves the name of this
             * interface to the same Class object.
             */
            Class<?> interfaceClass = null;
            try {
     
                interfaceClass = Class.forName(intf.getName(), false, loader);
            } catch (ClassNotFoundException e) {
     
            }
            if (interfaceClass != intf) {
     
                throw new IllegalArgumentException(
                    intf + " is not visible from class loader");
            }
            /*
             * Verify that the Class object actually represents an
             * interface.
             */
            if (!interfaceClass.isInterface()) {
     
                throw new IllegalArgumentException(
                    interfaceClass.getName() + " is not an interface");
            }
            /*
             * Verify that this interface is not a duplicate.
             */
            if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
     
                throw new IllegalArgumentException(
                    "repeated interface: " + interfaceClass.getName());
            }
        }

        String proxyPkg = null;     // package to define proxy class in
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

        /*
         * Record the package of a non-public proxy interface so that the
         * proxy class will be defined in the same package.  Verify that
         * all non-public proxy interfaces are in the same package.
         */
        for (Class<?> intf : interfaces) {
     
            int flags = intf.getModifiers();
            if (!Modifier.isPublic(flags)) {
     
                accessFlags = Modifier.FINAL;
                String name = intf.getName();
                int n = name.lastIndexOf('.');
                String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                if (proxyPkg == null) {
     
                    proxyPkg = pkg;
                } else if (!pkg.equals(proxyPkg)) {
     
                    throw new IllegalArgumentException(
                        "non-public interfaces from different packages");
                }
            }
        }

        if (proxyPkg == null) {
     
            // if no non-public proxy interfaces, use com.sun.proxy package
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }

        /*
         * Choose a name for the proxy class to generate.
         */
        long num = nextUniqueNumber.getAndIncrement();
        String proxyName = proxyPkg + proxyClassNamePrefix + num;

        /*
         * Generate the specified proxy class.
         */
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);
        try {
     
            return defineClass0(loader, proxyName,
                                proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
     
            /*
             * A ClassFormatError here means that (barring bugs in the
             * proxy class generation code) there was some other
             * invalid aspect of the arguments supplied to the proxy
             * class creation (such as virtual machine limitations
             * exceeded).
             */
            throw new IllegalArgumentException(e.toString());
        }
    }
}

这个类的注释说，通过指定的 ClassLoader 和 接口数组 用工厂方法生成 proxy class。 然后这个 proxy class 的名字是：

// Proxy class 的前缀是 “$Proxy”，
private static final String proxyClassNamePrefix = "$Proxy";

long num = nextUniqueNumber.getAndIncrement();

String proxyName = proxyPkg + proxyClassNamePrefix + num;

所以，动态生成的代理类名称是包名+$Proxy+id序号。

生成的过程，核心代码如下：

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);


return defineClass0(loader, proxyName,
                    proxyClassFile, 0, proxyClassFile.length);

下面用一张图让大家记住动态代理涉及到的角色。

多线程 详解(掌握这篇就够了)_第4张图片

红框中 $Proxy0 就是通过 Proxy 动态生成的。
$Proxy0 实现了要代理的接口。
$Proxy0 通过调用 InvocationHandler 来执行任务。

代理的作用

可能有同学会问，已经学习了代理的知识，但是，它们有什么用呢？

主要作用，还是在不修改被代理对象的源码上，进行功能的增强。

这在 AOP 面向切面编程领域经常见。

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

主要功能
日志记录，性能统计，安全控制，事务处理，异常处理等等。

上面的引用是百度百科对于 AOP 的解释，至于，如何通过代理来进行日志记录功能、性能统计等等，这个大家可以参考 AOP 的相关源码，然后仔细琢磨。

同注解一样，很多同学可能会有疑惑，我什么时候用代理呢？

这取决于你自己想干什么。你已经学会了语法了，其他的看业务需求。对于实现日志记录功能的框架来说，正合适。

至此，静态代理和动态代理者讲完了。

总结

  1. 代理分为静态代理和动态代理两种。
  2. 静态代理，代理类需要自己编写代码写成。
  3. 动态代理，代理类通过 Proxy.newInstance() 方法生成。
  4. 不管是静态代理还是动态代理，代理与被代理者都要实现两样接口，它们的实质是面向接口编程。
  5. 静态代理和动态代理的区别是在于要不要开发者自己定义 Proxy 类。
  6. 动态代理通过 Proxy 动态生成 proxy class，但是它也指定了一个 InvocationHandler 的实现类。
  7. 代理模式本质上的目的是为了增强现有代码的功能。

大佬的解释太全面了 膜拜了！！！有详细了解的可以看大佬博客，链接我放下面了

代理详解

lambda表达式

lambda表达式其实质属于函数式编程的概念

简化多线程，使用Lambda表达式

new Thread(()->{
     
   System.out.println("我使用了Lambda表达式");
}).start();

为什么要使用Lambda表达式

  • 避免匿名内部类定义过多
  • 可以让你的代码看起来很简洁
  • 去掉了一堆没有意义的代码，只留下核心的逻辑。

理解Lambda表达式

  • 理解Functional Interface（函数式接口）是学习Java8 lambda表达式的关键所在。

  • 函数式接口的定义

    • 任何接口，如果只包含唯一个抽象方法（接口中只存在一个方法），那么它就是一个函数式接口，前提是函数式接口的方法，才能使用lambda表达式

      class MyRunnable implements Runnable{
         
   @Override
   public void run() {
         
      System.out.println("我是子线程");
   }
}

    • 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

    • lambda表示只能有一行代码的情况下才能简化成一行，若有多行必须用大括号括起来

    • 若方法中含有参数，可以去掉参数类型，若含有多个参数，也可以去掉参数类型，要去掉都去掉，而且必须加上括号。

代码推到Lambda表达式 代码示例如下

public class TestLambda {
     

   //2、静态内部类
   static class ILike2 implements Like{
     

      @Override
      public void lambda() {
     
         System.out.println("我是静态内部类2");
      }
   }

   public static void main(String[] args) {
     

      Like iLike = new ILike();
      iLike.lambda();

      new ILike2().lambda();

      //3、局部内部类
      class ILike3 implements Like{
     
         @Override
         public void lambda() {
     
            System.out.println("我是局部内部类3");
         }
      }
      new ILike3().lambda();

      //4、匿名内部类 没有类的名称 要借助接口或者父类实现
      iLike=new Like() {
     
         @Override
         public void lambda() {
     
            System.out.println("我是匿名内部类4");
         }
      };

      iLike.lambda();

      //5、lambda表达式实现
      iLike=()->{
     
         System.out.println("我是lambdab 5");
      };
      iLike.lambda();


   }
}
//接口
interface Like{
     
   void lambda();
}
//1、外部类实现
class ILike implements Like{
     

   @Override
   public void lambda() {
     
      System.out.println("我是外部实现类1");
   }
}

三、线程状态（五大状态）

状态概念

线程共包括以下 5 种状态：(严格说应该有6种)

1. 新建状态(New): 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。

2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。

3. 运行状态(Running): 线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。

4. 阻塞状态(Blocked): 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

  • (01) 等待阻塞 – 通过调用线程的wait()方法，让线程等待某工作的完成。
  • (02) 同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
  • (03) 其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

5. 死亡状态(Dead): 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

详细解释线程的6种状态 线程六种状态详解

线程状态图：

多线程 详解(掌握这篇就够了)_第5张图片

多线程 详解(掌握这篇就够了)_第6张图片

线程方法

方法 说明
setPriority(int newPriority) 更改线程的优先级
static void sleep(long millis) 在指定的毫秒内让正在执行的线程进入休眠状态
void join() 等待该线程终止
static void yield() 暂停正在执行的线程对象，并执行其他的线程
void interrupt() 中断线程，别使用这个方法
boolean isAlive() 测试线程是否处于活动状态

停止线程（使用标志位）

  • 不推荐使用JDK提供的 stop()、 destroy()方法。【已废弃】
  • 推荐线程自己停止下来
  • 建议使用一个标志位进行终止变量 当flag=false，则终止线程运行。
public class TestStop implements Runnable{
     

   boolean flag=true;
   @Override
   public void run() {
     
      int i=0;
      while (flag){
     
         System.out.println("子线程"+i++);
      }
   }

   //标志位停止线程
   private void stop() {
     
      this.flag=false;
   }

   public static void main(String[] args) {
     

      TestStop testStop = new TestStop();
      new Thread(testStop).start();

      for (int i = 0; i < 1000; i++) {
     
         System.out.println("主线程"+i);
         if (i==900){
     
            testStop.stop();
            System.out.println("线程该停止了。。。。");
         }
      }
   }
}

主线程和子线程共同抢占CPU，两者交替执行，当主线程的i==900时，调用了子线程的stop方法，那么子线程停止就不在执行，那么此时程序中就存在一个主线程在执行，直到停止。

线程休眠（sleep）

  • sleep (时间) 指定当前线程阻塞的毫秒数；
  • sleep存在异常InterruptedException；
  • sleep时间达到后线程进入就绪状态；
  • sleep可以模拟网络延时，倒计时等。
  • 每一个对象都有一个锁，sleep不会释放锁；

模拟网络延迟

//模拟网络延时 放大问题的发生性
public class TestSleep implements Runnable {
     

   //模拟卖票
   public int tickets=50;
   @Override
   public void run() {
     

      while (tickets>0){
     
         try {
     
            Thread.sleep(2000);
         } catch (InterruptedException e) {
     
            e.printStackTrace();
         }
         System.out.println(Thread.currentThread().getName()+"买到了第"+tickets--+"张票");
      }

   }

   public static void main(String[] args) {
     


      TestSleep testSleep = new TestSleep();

      new Thread(testSleep,"小明").start();
      new Thread(testSleep,"小王").start();
      new Thread(testSleep,"老张").start();
   }
}

以上例子通过三个线程卖票，模拟网络延迟，放大了问题的发生性，我们知道当我们定义多个线程共同抢夺同一个资源时，也没有使用锁肯定是不安全的（两个人拿到同一张票），我们不使用睡眠时，很难发现；当我们使用了sleep后程序就实现了一个睡眠，可以放大问题的发生性，我们很容易看到问题发生的现状（两个人抢到了同一张票）。

sleep获取当前时间

//获取当前系统的时间
public class TestSleep2 {
     

   public static void main(String[] args) {
     

      //获取当前的时间
      Date date = new Date(System.currentTimeMillis());
      while (true){
     
         try {
     
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
            //更新当前时间
            date=new Date(System.currentTimeMillis());
         } catch (InterruptedException e) {
     
            e.printStackTrace();
         }
      }
   }
}

线程礼让（yield）

  • 礼让线程 让当前正在执行的线程暂停但不阻塞，是从运行状态返回到就绪状态
  • 将线程从运行状态转为就绪状态
  • 让cpu重新调度，礼让不一定成功！看CPU心情
public class TestYield implements Runnable{
     
   @Override
   public void run() {
     
      System.out.println(Thread.currentThread().getName()+"执行");
      //进行礼让，让另一个线程跑，可能不礼让成功
      Thread.yield();
      System.out.println(Thread.currentThread().getName()+"停止");
   }

   public static void main(String[] args) {
     
      TestYield testYield = new TestYield();

      new Thread(testYield,"a").start();
      new Thread(testYield,"b").start();

   }
}
礼让成功：
b执行
a执行
b停止
a停止
不礼让：
b执行
b停止
a执行
a停止

线程插队（join）

  • Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
  • 可以想象成插队
  • a b 两个线程，在a队伍跑的过程中，b线程来插队，那么a就发生了阻塞，停止执行，直到b线程执行完，a才能执行。
 */
//线程插队join
public class TestJoin implements  Runnable{
     
   @Override
   public void run() {
     
      for (int i = 0; i < 100; i++) {
     
         System.out.println("子线程"+i);
      }
   }

   public static void main(String[] args) {
     

      TestJoin testJoin = new TestJoin();
      Thread thread = new Thread(testJoin);
      thread.start();


      for (int i = 0; i < 500; i++) {
     
         //当我们主线程i==200时，让子线程进行一个插队
         if (i==50){
     
            try {
     
               thread.join();
            } catch (InterruptedException e) {
     
               e.printStackTrace();
            }
         }

         System.out.println("主线程"+i);
      }
   }
}

当主线程的i为50时，此时子线程要全部跑完

线程状态观测

多线程 详解(掌握这篇就够了)_第7张图片

    • NEW
      线程尚未开始在这个国家。
    • RUNNABLE
      处于这种状态中的java虚拟机执行的线程。
    • BLOCKED
      线程阻塞等待监控锁在这个国家。
    • WAITING
      处于这种状态的线程被无限期地等待另一个线程来执行特定的动作。
    • TIMED_WAITING
      处于这种状态的线程正在等待另一个线程上执行一个动作指定的等待时间。
    • TERMINATED
      处于这种状态的线程退出。

    一个线程可以在一个给定的时间点上只有一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。

    public class TestThreadState {
       

   public static void main(String[] args) {
       
      Thread thread=new Thread(()->{
       

         try {
       
            Thread.sleep(1000);
         } catch (InterruptedException e) {
       

         }
         System.out.println("子线程");
      });

      //创建完对象后，观察线程的状态
      Thread.State state = thread.getState();
      System.out.println(state);

      //start后线程进入就绪状态
      thread.start();
      System.out.println(thread.getState());

      while (state!=Thread.State.TERMINATED){
       
         //若线程不死 就一直输出
         //等待状态说明执行中，出现了阻塞睡眠
         try {
       
            Thread.sleep(100);
            state=thread.getState();
            System.out.println(state);
         } catch (InterruptedException e) {
       

         }
      }
      //线程停止之后不能再次运行，会出现异常
         //Exception in thread "main" java.lang.IllegalThreadStateException
		 //at java.lang.Thread.start(Thread.java:708)
		 //at com.zz.state.TestThreadState.main(TestThreadState.java:40)
      //thread.start();
   }
}
输出结果：
NEW
RUNNABLE
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
子线程
TERMINATED

线程优先级

  • Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
  • 线程的优先级用数字表示，范围从1~10.
    • Thread.MIN_PRIORITY = 1;
    • Thread.MAX_PRIORITY = 10;
    • Thread.NORM_PRIORITY = 5;
  • 使用以下方式改变或获取优先级
    • getPriority() . setPriority(int xxx)
  • 线程优先级最大设置为10，最小为1，不在这个范围内的都会报出异常
  • 每一个程序都是主线程先执行，后执行子线程，默认线程优先级为5

优先级的设定建议在start之前进行设置

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度，也有可能低优先级的线程先调度

public class TestPriority implements Runnable{
   @Override
   public void run() {
      System.out.println(Thread.currentThread().getName()+"----->"+Thread.currentThread().getPriority());
   }

   public static void main(String[] args) {

      System.out.println("主线程优先级"+Thread.currentThread().getPriority());

      TestPriority testPriority = new TestPriority();

      Thread thread1=new Thread(testPriority,"线程1");
      thread1.setPriority(1);
      thread1.start();

      Thread thread2=new Thread(testPriority,"线程2");
      thread2.setPriority(Thread.MAX_PRIORITY);//10
      thread2.start();

      Thread thread3=new Thread(testPriority,"线程3");
      thread3.setPriority(3);
      thread3.start();
   }
}

守护(daemon)线程

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕 如gc线程
  • 如,后台记录操作日志,监控内存,垃圾回收等待…
  • 设置为守护线程核心就是将线程的setDaemon(true)设置为true
//守护线程
public class TestDaemon {
     

   public static void main(String[] args) {
     


      God god = new God();

      You you = new You();

      Thread thread = new Thread(god);
      //将上帝设置为守护线程
      //默认为false,正常的线程都是用户线程
      thread.setDaemon(true);
      //开启守护线程
      thread.start();

      new Thread(you).start();
   }

}

//上帝模拟守护线程
class God implements Runnable{
     

   @Override
   public void run() {
     
      while (true){
     
         System.out.println("上帝一直保佑着你");
      }

   }
}

//用户线程
class You implements Runnable{
     
   @Override
   public void run() {
     
      for (int i = 0; i < 36500; i++) {
     
         System.out.println("hello world 第"+i+"天");
      }

      System.out.println("GoodBy world");
   }
}

当用户线程死后，我们看到守护线程还在执行一段时间，原因是当我们销毁用户线程后也需要一段时间，因为cpu切换速度比较快，所以我们的守护线程也会运行一段时间。

四、线程同步（重点）

并发和并行

并发是两个队列交替使用同一台咖啡机，并行是两个队列同时使用两台咖啡机，如果串行，一个队列使用一台咖啡机，那么哪怕前面那个人便秘了去厕所呆半天，后面的人也只能死等着他回来才能去接咖啡，这效率无疑是最低的。

多线程 详解(掌握这篇就够了)_第8张图片

并发是不是一个线程，并行是多个线程？

并发和并行都可以是很多个线程，就看这些线程能不能同时被（多个）cpu执行，如果可以就说明是并行，而并发是多个线程被（一个）cpu 轮流切换着执行。

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

  • CPU一核，模拟出来多条线程，天下武功，唯快不破，快速交替

并行（多个人一起行走）

  • CPU多核，多个线程可以同时执行；提高性能可以用线程池

并发编程的本质：充分利用CPU性能

线程同步

  • 现实生活中,我们会遇到 ” 同一个资源 , 多个人都想使用 ” 的问题 , 比如,食堂排队 打饭 , 每个人都想吃饭 , 最天然的解决办法就是 , 排队 . 一个个来.

  • 处理多线程问题时 , 多个线程访问同一个对象 , 并且某些线程还想修改这个对象 . 这时候我们就需要线程同步 . 线程同步其实就是一种等待机制 , 多个需要同时访问此对象的线程进入这个对象的等待池 形成队列, 等待前面线程使用完毕 , 下一个线程再使用

  • 由于同一进程的多个线程共享同一块存储空间 , 在带来方便的同时,也带来了访问 冲突问题 , 为了保证数据在方法中被访问时的正确性 , 在访问时加入 锁机制

    synchronized , 当一个线程获得对象的排它锁 , 独占资源 , 其他线程必须等待 , 使用后释放锁即可 . 存在以下问题 :

    • 一个线程持有锁会导致其他所有需要此锁的线程挂起 ;
    • 在多线程竞争下 , 加锁 , 释放锁会导致比较多的上下文切换 和 调度延时,引起性能问题 ;
    • 如果一个优先级高的线程等待一个优先级低的线程释放锁 会导致优先级倒置 , 引起性能问题

同步方法

  • 由于我们可以通过 private 关键字来保证数据对象只能被方法访问 , 所以我们只需要针对方法提出一套机制 , 这套机制就是 synchronized 关键字 , 它包括两种用法 synchronized 方法 和synchronized 块
    • synchronized 方法 是我们共享的资源通过一个方法执行 同步方法 : public synchronized void method(int args) {}
    • synchronized 块 是我们共享的资源是一个对象 块 synchronized (accout){ }
  • synchronized方法控制对 “对象” 的访问 , 每个对象对应一把锁 , 每个synchronized方法都必须获得调用该方法的对象的锁才能执行 , 否则线程会阻塞 , 方法一旦执行 , 就独占该锁 , 直到该方法返回才释放锁 , 后面被阻塞的线程才能获得这个锁 , 继续执行

缺陷 : 若将一个大的方法申明为synchronized 将会影响效率

同步方法弊端

多线程 详解(掌握这篇就够了)_第9张图片

同步块

  • 同步块 : synchronized (Obj ) { }
  • Obj 称之为 同步监视器
    • Obj 可以是任何对象 , 但是推荐使用共享资源作为同步监视器
    • 同步方法中无需指定同步监视器 , 因为同步方法的同步监视器就是this , 就是这个对象本身 , 或者是 class [ 反射中讲解 ]
  • 同步监视器的执行过程
    • 第一个线程访问 , 锁定同步监视器 , 执行其中代码 .
    • 第二个线程访问 , 发现同步监视器被锁定 , 无法访问 .
    • 第一个线程访问完毕 , 解锁同步监视器 .
    • 第二个线程访问, 发现同步监视器没有锁 , 然后锁定并访问

代码示例

卖票

这里多个线程资源抢占票，若不适用锁机制不同对象会抢到同一张票，还会造成票的负数，显然这是线程不安全的，那么我们使用synchronized方法实现线程安全

//多个对象进行抢票 通过给票上锁来实现线程安全
public class Ticket {
     
   public static void main(String[] args) {
     

      MyTicket myTicket = new MyTicket();
      new Thread(myTicket).start();
      new Thread(myTicket).start();
      new Thread(myTicket).start();
   }
}

class MyTicket implements Runnable {
     


   public int tickets = 20;

   boolean flag=true;
   @Override
   public void run() {
     
      while (true) {
     
         buy();
         try {
     
            Thread.sleep(10);
         } catch (InterruptedException e) {
     
            e.printStackTrace();
         }
      }
   }

   //synchronized 同步方法，锁的是 this MyTicket这个资源
   public synchronized void buy() {
     
      if (tickets<0){
     
         flag=false;
         return;
      }
         System.out.println(Thread.currentThread().getName() + "抢到了" + tickets--);
   }
}

取钱（ACID补充）

两个线程进行取钱，取同一个账户，若不加锁两个线程会同时操控一个资源进行，会造成当a取钱时，b也同时进行取钱，就会造成ab同时消耗这个资源，会造成数据的脏读。

补充

1、脏读：事务A读到了事务B未提交的数据。

2、不可重复读：事务A第一次查询得到一行记录row1，事务B提交修改后，事务A第二次查询得到row1，但列内容发生了变化。

3、幻读：事务A第一次查询得到一行记录row1，事务B提交修改后，事务A第二次查询得到两行记录row1和row2。

ACID特效

事务是恢复和并发控制的基本单位。

事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。

原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。

一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。

隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。

持久性（durability）。持久性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

/**
 * 模拟夫妻取钱，开启两个线程，同时取钱，一个账户
 */
public class Bannk {
     

   public static void main(String[] args) {
     
      Accout accout = new Accout(100,"卖废品");
      MyThread myThread1 = new MyThread(accout,50);
      myThread1.start();
      MyThread myThread2 = new MyThread(accout,50);
      myThread2.start();
   }
}

class Accout{
     
   //银行卡余额
   public int money;
   //存钱备注
   public String name;

   public Accout(int money, String name) {
     
      this.money = money;
      this.name = name;
   }
}

class MyThread extends Thread{
     

   public Accout accout;
   //取的钱
   public int quMoney;
   //手里的钱
   public int nowMoney;

   public MyThread(Accout accout, int quMoney) {
     
      this.accout = accout;
      this.quMoney = quMoney;
   }

   boolean flag=true;
   @Override
   public void run() {
     
      //锁的对象时变化的对象，这里若使用同步方法，指代this代表银行，明显不行
      //使用代码块，锁住变化的对象账户accout
         synchronized (accout){
     
            //判断取的钱 是否多余账户余额
            if (quMoney>accout.money){
     
               flag=false;
               System.out.println(Thread.currentThread().getName()+"取了"+quMoney+"银行卡余额不足，仅剩"+accout.money);
               return;
            }
            try {
     
               Thread.sleep(1000);
            } catch (InterruptedException e) {
     

            }

            //正常取钱
            accout.money=accout.money-quMoney;
            nowMoney+=quMoney;

            System.out.println(Thread.currentThread().getName()+"取了"+quMoney+",手里:"+nowMoney+",银行卡余额："+accout.money);
         }
   }
}

ArrayList

不安全原因是当两个线程同时执行的时候，将两个元素加到了同一个数组,就会造成集合的长度小于10000，

Vector 是县城线程安全的

public class unSafeList {
     

   public static void main(String[] args) {
     


      ArrayList<Object> list = new ArrayList<>();
      //Vector objects = new Vector<>();
      //不安全原因是当两个线程同时执行的时候，将两个元素加到了同一个数组

         for (int i = 0; i < 10000; i++) {
     
            new Thread(()->{
     
               //这里变化的资源 是list所以锁住该对象
               synchronized (list){
     
                  list.add(Thread.currentThread().getName());
               }

            }).start();
         }

      try {
     
         Thread.sleep(10);
      } catch (InterruptedException e) {
     
         e.printStackTrace();
      }

      System.out.println("集合中大小："+list.size());
   }
}
 
  
CopyOnWriteArrayList 线程安全
 
  
CopyOnWriteArrayList 是JUC下的一个方法，在java.util.concurrent.CopyOnWriteArrayList这个包下面
 
  
//线程安全
public class TestConyOnWriteArraylist {
     

   public static void main(String[] args) {
     
      CopyOnWriteArrayList<Object> list = new CopyOnWriteArrayList<>();

      for (int i = 0; i < 1000; i++) {
     
         new Thread(()->{
     
            list.add(Thread.currentThread().getName());
         }).start();
      }

      try {
     
         Thread.sleep(1000);
      } catch (InterruptedException e) {
     
         e.printStackTrace();
      }

      System.out.println(list.size());

   }
}

 
  
源码分析 CopyOnWriteArrayList为什么是线程安全的
 
  
public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
     
    private static final long serialVersionUID = 8673264195747942595L;

    /** The lock protecting all mutators */
    //这里使用了可重复锁，是JUC里面的锁，后面会讲到
    final transient ReentrantLock lock = new ReentrantLock();

    /** The array, accessed only via getArray/setArray. */
    //使用了volatile关键字 保证了原子性
    private transient volatile Object[] array;

    /**
     * Gets the array.  Non-private so as to also be accessible
     * from CopyOnWriteArraySet class.
     */
    final Object[] getArray() {
     
        return array;
    }

 
  
序列化和反序列化（Serializable）
 
  
什么是序列化接口？
 
  
 
   
一个对象序列化的接口，一个类只有实现了Serializable接口，它的对象才能被序列化。
 
  
 
  
什么是序列化？
 
  
 
   
序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它将流转换为对象。这两个过程结合起来，可以轻松地存储和传输数据。
 
  
 
  
序列化和反序列化转换过程
 
  
 
   
把对象转换为字节序列的过程称为对象的序列化
 
   
把字节序列恢复为对象的过程称为对象的反序列化
 
  
 
  
什么情况下需要序列化？
 
  
 
   
     
    
  • 当我们需要把对象的状态信息通过网络进行传输，或者需要将对象的状态信息持久化，以便将来使用时都需要把对象进行序列化
    •  
    
  • 为什么还要继承Serializable。那是存储对象在存储介质中，以便在下次使用的时候，可以很快捷的重建一个副本
    •  
   
 
  
 
  
在开发过程中并没有使用序列化 为什么那？来看一下序列化源码
 
  
多线程 详解(掌握这篇就够了)_第10张图片
 
  
一个接口里面什么内容都没有，我们可以将它理解成一个标识接口。
 
  
比如在课堂上有位学生遇到一个问题，于是举手向老师请教，这时老师帮他解答，那么这位学生的举手其实就是一个标识，自己解决不了问题请教老师帮忙解决。在Java中的这个Serializable接口其实是给jvm看的，通知jvm，我不对这个类做序列化了，你(jvm)帮我序列化就好了。
 
  
 
   
Serializable接口就是Java提供用来进行高效率的异地共享实例对象的机制，实现这个接口即可。
 
  
 
  
什么是JVM？
 
  
 
   
JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。
 
  
 
  
为什么要使用SerializableUID变量
 
  
 
   
从说明中我们可以看到，如果我们没有自己声明一个serialVersionUID变量,接口会默认生成一个serialVersionUID
 
  
 
  
但是强烈建议用户自定义一个serialVersionUID,因为默认的serialVersinUID对于class的细节非常敏感，反序列化时可能会导致InvalidClassException这个异常。
 
  
在前面我们已经新建了一个实体类User实现Serializable接口，并且定义了serialVersionUID变量。
 
  
 
   
读写文件的代码示例
 
  
 
  
import java.io.*;

/**
 * @Author zz
 * @Date 2021/3/16 16:03
 */
public class TestSerializable {
     

   public static void main(String[] args) {
     
      writeUser();
      readUser();
   }

   public static void writeUser(){
     
      User user = new User();
      user.setId(1);
      user.setName("zz");
      user.setAge(21);

      String file="G:\\idea\\bilibili\\kuang\\Thread\\src\\com\\zz\\ThreadSyn\\a.txt";
      try {
     
         ObjectOutputStream osw = new ObjectOutputStream(new FileOutputStream(new File(file)));
         osw.flush();
         osw.writeObject(user);
         System.out.println("序列化成功");
         osw.close();
      } catch (Exception e) {
     
         System.out.println(e.getMessage());
      }
   }

   public static void readUser(){
     
      String file="G:\\idea\\bilibili\\kuang\\Thread\\src\\com\\zz\\ThreadSyn\\a.txt";
      try {
     
         ObjectInputStream isr = new ObjectInputStream(new FileInputStream(new File(file)));
         User user = (User) isr.readObject();
         System.out.println(user.toString());
         System.out.println("反序列化成功");
      } catch (Exception e) {
     
         System.out.println(e.getMessage());
      }

   }
}

class User implements Serializable{
     

   private static final Long serialVersionUID=1L;
   private int id;
   private String name;
   private int age;

   public static Long getSerialVersionUID() {
     
      return serialVersionUID;
   }

   public int getId() {
     
      return id;
   }

   public void setId(int id) {
     
      this.id = id;
   }

   public String getName() {
     
      return name;
   }

   public void setName(String name) {
     
      this.name = name;
   }

   public int getAge() {
     
      return age;
   }

   public void setAge(int age) {
     
      this.age = age;
   }

   @Override
   public String toString() {
     
      return "User{" +
            "id=" + id +
            ", name='" + name + '\'' +
            ", age=" + age +
            '}';
   }
}

结果：
序列化成功
User{
     id=1, name='zz', age=21}
反序列化成功

 
  
这个serialVersionUID是用来辅助对象的序列化与反序列化的，原则上序列化后的数据当中的serialVersionUID与当前类当中的serialVersionUID一致，那么该对象才能被反序列化成功。这个serialVersionUID的详细的工作机制是：在序列化的时候系统将serialVersionUID写入到序列化的文件中去，当反序列化的时候系统会先去检测文件中的serialVersionUID是否跟当前的文件的serialVersionUID是否一致，如果一直则反序列化成功，否则就说明当前类跟序列化后的类发生了变化，比如是成员变量的数量或者是类型发生了变化，那么在反序列化时就会发生crash，并且回报出错误：
 
  
实体类不实现序列化接口，将会报以下异常：
 
  
java.io.NotSerializableException: com.zz.ThreadSyn.User
	at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
	at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
	at com.zz.ThreadSyn.TestSerializable.writeUser(TestSerializable.java:26)
	at com.zz.ThreadSyn.TestSerializable.main(TestSerializable.java:12)
java.io.WriteAbortedException: writing aborted; java.io.NotSerializableException: com.zz.ThreadSyn.User
	at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1572)
	at java.io.ObjectInputStream.readObject(ObjectInputStream.java:428)
	at com.zz.ThreadSyn.TestSerializable.readUser(TestSerializable.java:38)
	at com.zz.ThreadSyn.TestSerializable.main(TestSerializable.java:13)
Caused by: java.io.NotSerializableException: com.zz.ThreadSyn.User
	at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
	at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
	at com.zz.ThreadSyn.TestSerializable.writeUser(TestSerializable.java:26)
	at com.zz.ThreadSyn.TestSerializable.main(TestSerializable.java:12)


 
  
死锁
 
  
     
   
  • 多个线程各自占有一些共享资源 , 并且互相等待其他线程占有的资源才能运行 , 而导致两个或者多个线程都在等待对方释放资源 , 都停止执行的情形 . 某一个同步块 同时拥有 “ 两个以上对象的锁 ” 时 , 就可能会发生 “ 死锁 ” 的问题 .
    •  
  
 
  
代码示例
 
  
代码示例 小明 小王两个线程 枪 布娃娃 两个资源 小明首先拥有枪资源，小王首先拥有布娃娃资源；两个线程各自争夺对方手中的资源，产生死锁
 
  
public class DeadLock {
     

   public static void main(String[] args) {
     

      DeadThread thread1= new DeadThread(0,"小明");
      thread1.start();

      DeadThread thread2= new DeadThread(1,"小王");
      thread2.start();

   }
}

//两个资源
//枪
class Gun{
     

   String name="枪";


}
//布娃娃
class Doll {
     

   String name = "布娃娃";

}



class DeadThread extends Thread{
     

   static Gun gun=new Gun();

   static Doll doll=new Doll();

   int choice;
   String name;

   public DeadThread(int choice,String name){
     
      this.choice=choice;
      this.name=name;
   }

   @Override
   public void run() {
     
      makeup();
   }


   public void makeup(){
     
      if (choice==0){
     
         synchronized (gun){
     
            System.out.println(Thread.currentThread().getName()+"获得了----》"+gun.name+"的锁");
            //当走在这里的时候，小王也拿到了doll的锁并没有释放，
            synchronized (doll){
     
               System.out.println(Thread.currentThread().getName()+"获得了----》"+gun.name+"的锁");
            }
         }
      }else {
     
         synchronized (doll){
     
            System.out.println(Thread.currentThread().getName()+"获得了----》"+doll.name+"的锁");
            //这里小明一开始就拿到了 gun的锁并没有释放，故就产生了死锁
            synchronized (gun){
     
               System.out.println(Thread.currentThread().getName()+"获得了----》"+gun.name+"的锁");
            }
         }
      }
   }
}


 
  
结果 程序一直停在此状态，也不停止
 
  
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RPnBjyzx-1616034588102)(C:\Users\张哲\AppData\Local\Temp\1615965740288.png)]
 
  
解决死锁
 
  
当小王想要抢小明手中枪的时候，必须等待对方释放锁后，才能拿得到，不在产生死锁
 
  
public void makeup(){
     
   if (choice==0){
     
      synchronized (gun){
     
         System.out.println(Thread.currentThread().getName()+"获得了----》"+gun.name+"的锁");
         //当走在这里的时候，小王也拿到了doll的锁并没有释放，
      }
      try {
     
         Thread.sleep(100);
      } catch (InterruptedException e) {
     
         e.printStackTrace();
      }
      synchronized (doll){
     
         System.out.println(Thread.currentThread().getName()+"获得了----》"+doll.name+"的锁");
      }
   }else {
     
      synchronized (doll){
     
         System.out.println(Thread.currentThread().getName()+"获得了----》"+doll.name+"的锁");
         //这里小明一开始就拿到了 gun的锁并没有释放，故就产生了死锁

      }
      try {
     
         Thread.sleep(100);
      } catch (InterruptedException e) {
     
         e.printStackTrace();
      }
      synchronized (gun){
     
         System.out.println(Thread.currentThread().getName()+"获得了----》"+gun.name+"的锁");
      }
   }
}

 
  
多线程 详解(掌握这篇就够了)_第11张图片
 
  
死锁避免方法
 
  
产生死锁的四个必要条件：
 
  
     
   
  1. 互斥条件：一个资源每次只能被一个进程使用。
    2.  
   
  2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
    3.  
   
  3. 不剥夺条件 : 进程已获得的资源，在末使用完之前，不能强行剥夺。
    4.  
   
  4. 循环等待条件 : 若干进程之间形成一种头尾相接的循环等待资源关系。
    5.  
  
 
  
 
   
上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生
 
  
 
  
Lock（锁）
 
  
     
   
  • 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
    •  
   
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
    •  
   
  • ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁
    •  
  
 
  
public class TestLock {
     

   public static void main(String[] args) {
     
      LockThread lockThread = new LockThread();

      new Thread(lockThread).start();
      new Thread(lockThread).start();
      new Thread(lockThread).start();


   }
}

class LockThread implements Runnable {
     

   private int tickets = 10;
   ReentrantLock lock = new ReentrantLock();

   @Override
   public void run() {
     
      while (true) {
     

         try {
     
            lock.lock();
            if (tickets > 0) {
     
               System.out.println(Thread.currentThread().getName() + "---->" + tickets--);
               Thread.sleep(1000);
            } else {
     
               break;
            }

         } catch (Exception e) {
     
            e.printStackTrace();
         } finally {
     
            lock.unlock();
         }
      }

   }
}

 
  
synchronized 与 Lock 的对比
 
  
     
   
  • Lock是显式锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放
    •  
   
  • Lock只有代码块锁，synchronized有代码块锁和方法锁
    •  
   
  • 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
    •  
   
  • 优先使用顺序： 
    
       
     
    • Lock > 同步代码块（已经进入了方法体，分配了相应资源）> 同步方法（在方法体之外）
      •  
    
     
    •  
  
 
  
线程协作
 
  
生产者消费者模式
 
  
线程通信
 
  
     
   
  • 应用场景 : 生产者和消费者问题
    •  
   
  • 假设仓库中只能存放一件产品 , 生产者将生产出来的产品放入仓库 , 消费者将仓库中产品取走消费 .
    •  
   
  • 如果仓库中没有产品 , 则生产者将产品放入仓库 , 否则停止生产并等待 , 直到仓库中的产品被消费者取走为止 .
    •  
   
  • 如果仓库中放有产品 , 则消费者可以将产品取走消费 , 否则停止消费并等待 ,直到仓库中再次放入产品为止。
    •  
  
 
  
这是一个线程同步问题 , 生产者和消费者共享同一个资源 , 并且生产者和消费者之 间相互依赖 , 互为条件 .
 
  
     
   
  • 对于生产者 , 没有生产产品之前 , 要通知消费者等待 . 而生产了产品之后 , 又需要马上通知消费者消费
    •  
   
  • 对于消费者 , 在消费之后 , 要通知生产者已经结束消费 , 需要生产新的产品以供消费.
    •  
   
  • 产者消费者问题中 , 仅有synchronized是不够的
    •  
   
  • nchronized 可阻止并发更新同一个共享资源 , 实现了同步
    •  
   
  • nchronized 不能用来实现不同线程之间的消息传递 (通信)
    •  
  
 
  
Java提供了几个方法解决线程之间的通信问题
 
  
多线程 详解(掌握这篇就够了)_第12张图片
 
  
 
   
注意：均是Object类的方法 , 都只能在同步方法或者同步代码块中使用,否则会抛出异常IllegalMonitorStateException
 
  
 
  
生产者消费者问题
 
  
管程法
 
  
并发协作模型 “ 生产者 / 消费者模式 ” —>管程法
 
  
生产者 : 负责生产数据的模块 (可能是方法 , 对象 , 线程 , 进程) ;
 
  
消费者 : 负责处理数据的模块 (可能是方法 , 对象 , 线程 , 进程) ;
 
  
缓冲区 : 消费者不能直接使用生产者的数据 , 他们之间有个 “ 缓冲区
 
  
生产者将生产好的数据放入缓冲区 , 消费者从缓冲区拿出数据
 
  
public class TestShoppig {
     

   public static void main(String[] args) {
     

      SyContainer syContainer = new SyContainer();

      new Product(syContainer).start();
      new Consumer(syContainer).start();

   }
}

//定义两个线程 生产者 消费者
class Product extends Thread {
     

   SyContainer syContainer;
   public Product(SyContainer syContainer){
     
      this.syContainer=syContainer;
   }

   @Override
   public void run() {
     
      super.run();

      for (int i = 1; i < 100; i++) {
     
         syContainer.push(new Chicken(i));
         System.out.println("生产了--->" + i);
      }
   }
}

class Consumer extends Thread {
     

   SyContainer syContainer;
   public Consumer(SyContainer syContainer){
     
      this.syContainer=syContainer;
   }

   @Override
   public void run() {
     
      super.run();
      for (int i = 1; i < 100; i++) {
     
         Chicken pop = syContainer.pop();
         System.out.println("消费了"+pop.count);
      }
   }
}

//鸡
class Chicken {
     
   //数量
   int count;

   public Chicken(int id) {
     
      this.count = id;
   }
}

//盘子
class SyContainer {
     

   int count = 0;
   //一个盘子放10只鸡
   Chicken[] chickens = new Chicken[10];

   //生产者 放入产品
   public synchronized void push(Chicken chicken) {
     
      if (count == chickens.length) {
     
         //盘子已满 通知消费者消费,生产者等待
         try {
     
            this.wait();
         } catch (InterruptedException e) {
     
            e.printStackTrace();
         }
      } else {
     
         //未满 生产丢入盘子
         chickens[count] = chicken;
         count++;
         //通知消费者消费,唤醒消费者
         this.notifyAll();

      }
   }

   //消费者消费产品
   public synchronized Chicken pop() {
     
      if (count == 0) {
     
         //盘子为空，通知生产者生产,消费者等待\\
         try {
     
            this.wait();
         } catch (InterruptedException e) {
     
            e.printStackTrace();
         }
      }
      //可以消费
      count--;
      Chicken chicken = chickens[count];
      this.notifyAll();
      return chicken;
   }
}


 
  
信号灯法
 
  
并发协作模型 “ 生产者 / 消费者模式 ”
 
  
package com.zz.ThreadComm;

/**
 * @Author zz
 * @Date 2021/3/17 21:48
 */
public class TestTv {
     

   public static void main(String[] args) {
     

      Tv tv = new Tv();
      new Thread(new Player(tv)).start();
      new Thread(new Watcher(tv)).start();
   }
}

class Tv {
     

   //演员表演 观众观看
   private String voice;

   boolean flag=true;

   public synchronized void play(String voice){
     
      if (!flag){
     
         try {
     
            this.wait();
         } catch (InterruptedException e) {
     
            e.printStackTrace();
         }
      }
      System.out.println("表演了"+voice);
      //唤醒观众去看
      this.notifyAll();
      this.flag=!this.flag;
      this.voice=voice;
   }

   public synchronized void watch(){
     
      if (flag){
     
         try {
     
            //等待演出
            this.wait();
         } catch (InterruptedException e) {
     
            e.printStackTrace();
         }
      }
      System.out.println("观看了--->"+voice);

      this.notifyAll();
      this.flag=!this.flag;
   }
}

//演出者
class Player implements Runnable{
     

   Tv tv;

   public Player(Tv tv) {
     
      this.tv = tv;
   }

   @Override
   public void run() {
     

      for (int i = 0; i < 10; i++) {
     
         if (i%2==0){
     
            tv.play("光头强");
         }
         tv.play("喜洋洋");
      }
   }


}

//观众
class Watcher implements Runnable{
     

   Tv tv;

   public Watcher(Tv tv) {
     
      this.tv = tv;
   }

   @Override
   public void run() {
     
      for (int i = 0; i < 10; i++) {
     
         tv.watch();
      }
   }
}

 
  
线程池法
 
  
     
   
  • 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
    •  
   
  • 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。
    •  
   
  • 可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
    •  
   
  • 好处： 
    
       
     
    • 提高响应速度（减少了创建新线程的时间）
      •  
     
    • 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
      •  
     
    • 便于线程管理(…) 
      
         
       
      • corePoolSize：核心池的大小
        •  
       
      • maximumPoolSize：最大线程数
        •  
       
      • keepAliveTime：线程没有任务时最多保持多长时间后会终止
        •  
      
       
      •  
    
     
    •  
   
  • JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
    •  
   
  • ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor 
    
       
     
    • void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
      •  
     
    •  Future submit(Callable task)：执行任务，有返回值，一般又来执行Callable
      •  
     
    • void shutdown() ：关闭连接池
      •  
    
     
    •  
   
  • Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
    •  
  
 
  
public class TestPool {
     

   public static void main(String[] args) {
     
      //创建线程池 后面参数为线程池大小
      ExecutorService executorService = Executors.newFixedThreadPool(5);

      executorService.execute(new ThreadPool());
      executorService.execute(new ThreadPool());
      executorService.execute(new ThreadPool());
      executorService.execute(new ThreadPool());
      executorService.execute(new ThreadPool());

      //关闭连接
      executorService.shutdown();


   }
}

class ThreadPool implements Runnable {
     

   @Override
   public void run() {
     
         System.out.println(Thread.currentThread().getName());
   }
}

 
  
结果：
 
  
多线程 详解(掌握这篇就够了)_第13张图片
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(线程,多线程,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
    
                    
    • 
                    
  • ios GCD
                        _Waiting_

                        
    1.GCD任务和队列学习GCD之前，先来了解GCD中两个核心概念：任务和队列。任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。同步执行（sync）：同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等
    
                    
    • 
                    
  • 简单了解 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
    
                    
    • 
                    
  • 多线程之——ExecutorCompletionService
                        阿福德

                        
    在我们开发中，经常会遇到这种情况，我们起多个线程来执行，等所有的线程都执行完成后，我们需要得到个线程的执行结果来进行聚合处理。我在内部代码评审时，发现了不少这种情况。看很多同学都使用正确，但比较啰嗦，效率也不高。本文介绍一个简单处理这种情况的方法：直接上代码：publicclassExecutorCompletionServiceTest{@TestpublicvoidtestExecutorCo
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • python多线程程序设计 之一
                        IT_Beijing_BIT
#Python程序设计语言python
                        
    python多线程程序设计之一全局解释器锁线程APIsthreading.active_count()threading.current_thread()threading.excepthook(args,/)threading.get_native_id()threading.main_thread()threading.stack_size([size])线程对象成员函数构造器start/ru
    
                    
    • 
                    
  • 白骑士的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
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • Python多线程实现大规模数据集高效转移
                        sand&wich
网络python服务器
                        
    背景在处理大规模数据集时，通常需要在不同存储设备、不同服务器或文件夹之间高效地传输数据。如果采用单线程传输方式，当数据量非常大时，整个过程会非常耗时。因此，通过多线程并行处理可以大幅提升数据传输效率。本文将分享一个基于Python多线程实现的高效数据传输工具，通过遍历源文件夹中的所有文件，将它们移动到目标文件夹。工具和库这个数据集转移工具主要依赖于以下Python标准库：os：用于文件系统操作，如
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • Python实现下载当前年份的谷歌影像
                        sand&wich
python开发语言
                        
    在GIS项目和地图应用中，获取最新的地理影像数据是非常重要的。本文将介绍如何使用Python代码从Google地图自动下载当前年份的影像数据，并将其保存为高分辨率的TIFF格式文件。这个过程涉及地理坐标转换、多线程下载和图像处理。关键功能该脚本的核心功能包括：坐标转换：支持WGS-84与WebMercator投影之间转换，以及处理中国GCJ-02偏移。自动化下载：多线程下载地图瓦片，提高效率。图像
    
                    
    • 
                    
  • 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
    
                    
    • 
                                
  • SAX解析xml文件
                                    小猪猪08
xml
                                    
    1.创建SAXParserFactory实例 
2.通过SAXParserFactory对象获取SAXParser实例 
3.创建一个类SAXParserHander继续DefaultHandler，并且实例化这个类 
4.SAXParser实例的parse来获取文件 
    public static void main(String[] args) { 
 //
    
                                
    • 
                                
  • 为什么mysql里的ibdata1文件不断的增长？
                                    brotherlamp
linuxlinux运维linux资料linux视频linux运维自学
                                    
    我们在 Percona 支持栏目经常收到关于 MySQL 的 ibdata1 文件的这个问题。 
当监控服务器发送一个关于 MySQL 服务器存储的报警时，恐慌就开始了 —— 就是说磁盘快要满了。 
一番调查后你意识到大多数地盘空间被 InnoDB 的共享表空间 ibdata1 使用。而你已经启用了 innodbfileper_table，所以问题是： 
ibdata1存了什么？ 
当你启用了 i
    
                                
    • 
                                
  • Quartz-quartz.properties配置
                                    eksliang
quartz
                                    
    其实Quartz JAR文件的org.quartz包下就包含了一个quartz.properties属性配置文件并提供了默认设置。如果需要调整默认配置，可以在类路径下建立一个新的quartz.properties，它将自动被Quartz加载并覆盖默认的设置。 
  
下面是这些默认值的解释 
#-----集群的配置
org.quartz.scheduler.instanceName =
    
                                
    • 
                                
  • informatica session的使用
                                    18289753290
workflowsessionlogInformatica
                                    
    如果希望workflow存储最近20次的log，在session里的Config  Object设置，log  options做配置，save  session log :sessions  run  ;savesessio log for  these runs:20 
session下面的source 里面有个tracing 
    
                                
    • 
                                
  • Scrapy抓取网页时出现CRC check failed 0x471e6e9a != 0x7c07b839L的错误
                                    酷的飞上天空
scrapy
                                    
    Scrapy版本0.14.4 
出现问题现象： 
  
ERROR: Error downloading <GET http://xxxxx  CRC check failed 
  
解决方法 
  
1.设置网络请求时的header中的属性'Accept-Encoding': '*;q=0' 
  
明确表示不支持任何形式的压缩格式，避免程序的解压
    
                                
    • 
                                
  • java Swing小集锦
                                    永夜-极光
java swing
                                    
    1.关闭窗体弹出确认对话框 
  1.1   this.setDefaultCloseOperation (JFrame.DO_NOTHING_ON_CLOSE); 
  1.2   
	this.addWindowListener (
				new WindowAdapter () {
					public void windo
    
                                
    • 
                                
  • 强制删除.svn文件夹
                                    随便小屋
java
                                    
      
        在windows上，从别处复制的项目中可能带有.svn文件夹，手动删除太麻烦，并且每个文件夹下都有。所以写了个程序进行删除。因为.svn文件夹在windows上是只读的，所以用File中的delete()和deleteOnExist()方法都不能将其删除，所以只能采用windows命令方式进行删除
    
                                
    • 
                                
  • GET和POST有什么区别？及为什么网上的多数答案都是错的。
                                    aijuans
get post
                                    
      
    如果有人问你，GET和POST，有什么区别？你会如何回答？ 我的经历 
     前几天有人问我这个问题。我说GET是用于获取数据的，POST，一般用于将数据发给服务器之用。 
    这个答案好像并不是他想要的。于是他继续追问有没有别的区别？我说这就是个名字而已，如果服务器支持，他完全可以把G
    
                                
    • 
                                
  • 谈谈新浪微博背后的那些算法
                                    aoyouzi
谈谈新浪微博背后的那些算法
                                    
    本文对微博中常见的问题的对应算法进行了简单的介绍，在实际应用中的算法比介绍的要复杂的多。当然，本文覆盖的主题并不全，比如好友推荐、热点跟踪等就没有涉及到。但古人云“窥一斑而见全豹”，希望本文的介绍能帮助大家更好的理解微博这样的社交网络应用。 
微博是一个很多人都在用的社交应用。天天刷微博的人每天都会进行着这样几个操作：原创、转发、回复、阅读、关注、@等。其中，前四个是针对短博文，最后的关注和@则针
    
                                
    • 
                                
  • Connection reset 连接被重置的解决方法
                                    百合不是茶
java字符流连接被重置
                                    
    流是java的核心部分,,昨天在做android服务器连接服务器的时候出了问题,就将代码放到java中执行,结果还是一样连接被重置 
  
被重置的代码如下; 
  
客户端代码; 
package 通信软件服务器;

import java.io.BufferedWriter;
import java.io.OutputStream;
import java.io.O
    
                                
    • 
                                
  • web.xml配置详解之filter
                                    bijian1013
javaweb.xmlfilter
                                    
    一.定义 
<filter>
	<filter-name>encodingfilter</filter-name>
	<filter-class>com.my.app.EncodingFilter</filter-class>
	<init-param>
		<param-name>encoding<
    
                                
    • 
                                
  • Heritrix
                                    Bill_chen
多线程xml算法制造配置管理
                                    
    作为纯Java语言开发的、功能强大的网络爬虫Heritrix，其功能极其强大，且扩展性良好，深受热爱搜索技术的盆友们的喜爱，但它配置较为复杂，且源码不好理解，最近又使劲看了下，结合自己的学习和理解，跟大家分享Heritrix的点点滴滴。 
Heritrix的下载（http://sourceforge.net/projects/archive-crawler/）安装、配置，就不罗嗦了，可以自己找找资
    
                                
    • 
                                
  • 【Zookeeper】FAQ
                                    bit1129
zookeeper
                                    
    1.脱离IDE，运行简单的Java客户端程序 
#ZkClient是简单的Zookeeper~$ java -cp "./:zookeeper-3.4.6.jar:./lib/*" ZKClient   
  
1. Zookeeper是的Watcher回调是同步操作，需要添加异步处理的代码 
2. 如果Zookeeper集群跨越多个机房，那么Leader/
    
                                
    • 
                                
  • The user specified as a definer ('aaa'@'localhost') does not exist
                                    白糖_
localhost
                                    
    今天遇到一个客户BUG，当前的jdbc连接用户是root，然后部分删除操作都会报下面这个错误：The user specified as a definer ('aaa'@'localhost') does not exist 
最后找原因发现删除操作做了触发器，而触发器里面有这样一句 
  
 /*!50017 DEFINER = ''aaa@'localhost' */ 
 原来最初
    
                                
    • 
                                
  • javascript中showModelDialog刷新父页面
                                    bozch
JavaScript刷新父页面showModalDialog
                                    
    在页面中使用showModalDialog打开模式子页面窗口的时候，如果想在子页面中操作父页面中的某个节点，可以通过如下的进行： 
      window.showModalDialog('url',self,‘status...’); // 首先中间参数使用self 
      在子页面使用w
    
                                
    • 
                                
  • 编程之美-买书折扣
                                    bylijinnan
编程之美
                                    
    


import java.util.Arrays;

public class BookDiscount {

	/**编程之美 买书折扣

书上的贪心算法的分析很有意思，我看了半天看不懂，结果作者说，贪心算法在这个问题上是不适用的。。
下面用动态规划实现。
哈利波特这本书一共有五卷，每卷都是8欧元，如果读者一次购买不同的两卷可扣除5%的折扣，三卷10%，四卷20%，五卷
    
                                
    • 
                                
  • 关于struts2.3.4项目跨站执行脚本以及远程执行漏洞修复概要
                                    chenbowen00
strutsWEB安全
                                    
    因为近期负责的几个银行系统软件，需要交付客户，因此客户专门请了安全公司对系统进行了安全评测，结果发现了诸如跨站执行脚本，远程执行漏洞以及弱口令等问题。 
下面记录下本次解决的过程以便后续 
1、首先从最简单的开始处理，服务器的弱口令问题，首先根据安全工具提供的测试描述中发现应用服务器中存在一个匿名用户，默认是不需要密码的，经过分析发现服务器使用了FTP协议， 
而使用ftp协议默认会产生一个匿名用
    
                                
    • 
                                
  • [电力与暖气]煤炭燃烧与电力加温
                                    comsci

                                    
     
      在宇宙中,用贝塔射线观测地球某个部分,看上去,好像一个个马蜂窝,又像珊瑚礁一样,原来是某个国家的采煤区..... 
 
      不过,这个采煤区的煤炭看来是要用完了.....那么依赖将起燃烧并取暖的城市,在极度严寒的季节中...该怎么办呢? 
 
  &nbs
    
                                
    • 
                                
  • oracle O7_DICTIONARY_ACCESSIBILITY参数
                                    daizj
oracle
                                    
    O7_DICTIONARY_ACCESSIBILITY参数控制对数据字典的访问.设置为true,如果用户被授予了如select any table等any table权限,用户即使不是dba或sysdba用户也可以访问数据字典.在9i及以上版本默认为false,8i及以前版本默认为true.如果设置为true就可能会带来安全上的一些问题.这也就为什么O7_DICTIONARY_ACCESSIBIL
    
                                
    • 
                                
  • 比较全面的MySQL优化参考
                                    dengkane
mysql
                                    
    本文整理了一些MySQL的通用优化方法，做个简单的总结分享，旨在帮助那些没有专职MySQL DBA的企业做好基本的优化工作，至于具体的SQL优化，大部分通过加适当的索引即可达到效果，更复杂的就需要具体分析了，可以参考本站的一些优化案例或者联系我，下方有我的联系方式。这是上篇。 
  
1、硬件层相关优化 
  
1.1、CPU相关 
  
在服务器的BIOS设置中，可
    
                                
    • 
                                
  • C语言homework2，有一个逆序打印数字的小算法
                                    dcj3sjt126com
c
                                    
    #h1# 
  
0、完成课堂例子 
1、将一个四位数逆序打印 
1234 ==> 4321 
实现方法一： 
# include <stdio.h>

int main(void)
{
	int i = 1234;
	int one = i%10;
	int two =  i / 10 % 10;
	int three = i / 100 % 10;

    
                                
    • 
                                
  • apacheBench对网站进行压力测试
                                    dcj3sjt126com
apachebench
                                    
       ab 的全称是 ApacheBench ， 是 Apache 附带的一个小工具 ， 专门用于 HTTP Server 的 benchmark testing ， 可以同时模拟多个并发请求。前段时间看到公司的开发人员也在用它作一些测试，看起来也不错，很简单，也很容易使用，所以今天花一点时间看了一下。 
通过下面的一个简单的例子和注释，相信大家可以更容易理解这个工具的使用。 
    
                                
    • 
                                
  • 2种办法让HashMap线程安全
                                    flyfoxs
javajdkjni
                                    
    多线程之--2种办法让HashMap线程安全 
多线程之--synchronized 和reentrantlock的优缺点 
多线程之--2种JAVA乐观锁的比较( NonfairSync VS. FairSync) 
  
  
HashMap不是线程安全的,往往在写程序时需要通过一些方法来回避.其实JDK原生的提供了2种方法让HashMap支持线程安全. 
  

    
                                
    • 
                                
  • Spring Security（04）——认证简介
                                    234390216
Spring Security认证过程
                                    
    认证简介 
目录 
1.1     认证过程 
1.2     Web应用的认证过程 
1.2.1    ExceptionTranslationFilter 
1.2.2    在request之间共享SecurityContext 
   

1
    
                                
    • 
                                
  • Java 位运算
                                    Javahuhui
java位运算
                                    
    // 左移( << ) 低位补0 
// 0000 0000 0000 0000 0000 0000 0000 0110 然后左移2位后，低位补0： 
// 0000 0000 0000 0000 0000 0000 0001 1000 
System.out.println(6 << 2);// 运行结果是24 
 
// 右移( >> ) 高位补"
    
                                
    • 
                                
  • mysql免安装版配置
                                    ldzyz007
mysql
                                    
    1、my-small.ini是为了小型数据库而设计的。不应该把这个模型用于含有一些常用项目的数据库。 
2、my-medium.ini是为中等规模的数据库而设计的。如果你正在企业中使用RHEL,可能会比这个操作系统的最小RAM需求(256MB)明显多得多的物理内存。由此可见，如果有那么多RAM内存可以使用，自然可以在同一台机器上运行其它服务。 
3、my-large.ini是为专用于一个SQL数据
    
                                
    • 
                                
  • MFC和ado数据库使用时遇到的问题
                                    你不认识的休道人
sqlC++mfc
                                    
    =================================================================== 
第一个 
=================================================================== 
 
try{
		CString sql;
	sql.Format("select * from p
    
                                
    • 
                                
  • 表单重复提交Double Submits
                                    rensanning
double
                                    
    可能发生的场景： 
 
 
 *多次点击提交按钮  
 *刷新页面  
 *点击浏览器回退按钮  
 *直接访问收藏夹中的地址  
 *重复发送HTTP请求（Ajax） 
 
（1）点击按钮后disable该按钮一会儿，这样能避免急躁的用户频繁点击按钮。 
这种方法确实有些粗暴，友好一点的可以把按钮的文字变一下做个提示，比如Bootstrap的做法： 
http://getbootstrap.co
    
                                
    • 
                                
  • Java String 十大常见问题
                                    tomcat_oracle
java正则表达式
                                    
    　1.字符串比较，使用“==”还是equals()?   　　"=="判断两个引用的是不是同一个内存地址(同一个物理对象)。   　　equals()判断两个字符串的值是否相等。   　　除非你想判断两个string引用是否同一个对象，否则应该总是使用equals()方法。   　　如果你了解字符串的驻留(String Interning)则会更好地理解这个问题。   　 
　
    
                                
    • 
                                
  • SpringMVC 登陆拦截器实现登陆控制
                                    xp9802
springMVC
                                    
    思路，先登陆后，将登陆信息存储在session中，然后通过拦截器，对系统中的页面和资源进行访问拦截，同时对于登陆本身相关的页面和资源不拦截。 
  
实现方法： 
        1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23  
    
                                
    •