JAVA-多线程

创建多线程

• extends thread

public class KillThread extends Thread{
	@Override
    public void run(){}
}

• implement runnable

public class Battle implements Runnable{
	@Override
    public void run(){}
}

• callable

public class CallableTask implements Callable {
    @Override
    public Object call() {
        return count;
    }
}

• 线程池

ExecutorService service = Executors.newCachedThreadPool();
// ExecutorService service = Executors.newFixedThreadPool(5);
// ExecutorService service = Executors.newSingleThreadExecutor();
  for(int i = 0;i < 5;i++){
    service.execute(new TestThread());
  }
  service.shutdown();

线程优先级

线程有10个优先级，常用的有MAX_PRIORITY(10), NORM_PRIORITY(5), MIN_PRIORITY(1).

多线程常用方法

• start：启动一个多线程.t1.start()
• join: 加入到当前线程，即子线程（t1）结束后，才继续往下执行。t1.join();
• setDaemon: 最后结束的线程，通常用来做日志和统计工作。t1.setDaemon(true)
• setPriority：t1.setPriority(5);
• yield()：临时暂停，使得其他线程获得更多的资源。Thread.yield();
• sleep: Thread.sleep(1000);
• uncaughtExceptionHandler()： 处理非正常的线程中断

线程同步

多个线程同时操作一个资源，可能会出现问题。使用synchronized解决线程同步问题。

synchronized

原理：https://blog.csdn.net/xueba8/article/details/88753443
普通同步方法；静态同步方法；同步代码块

• 对象锁

  • synchronized 代码块，锁住的是括号内的对象。

  Thread t = new Thread(){
                  public void run(){
                       //任何线程要修改hp的值，必须先占用someObject
                      synchronized (someObject) {}
                  }
              };
  

  • synchronized 方法，锁住的是当前实例的对象

      //直接在方法前加上修饰符synchronized
      //其所对应的同步对象，就是this
      public synchronized void recover(){}
  

• 类锁

  • 静态方法，锁住的是当前类的class对象

    public static synchronized void obj3() {}
    

  • 类

    synchronized (test.class) {}
    

Lock: https://blog.csdn.net/zd836614437/article/details/114503381

Synchronized 和 Lock的区别：

• Lock是一个接口，而synchronized是Java中的关键字；
• synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
• Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；（Lock对于开发者更加灵活）
• 通过Lock可以知道有没有成功获取锁。
• Lock可以提高多个线程进行读操作的效率。

在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。

线程交互

• wait: this.wait()表示: 让占用了这个同步对象的线程，临时释放当前的占用，并且等待。 所以调用wait是有前提条件的，一定是在synchronized块里，否则就会出错。
• notify: this.notify(): 通知一个等待在这个同步对象上的线程，你可以苏醒过来了，有机会重新占用当前对象了。
• notifyAll: this.notifyAll(): 通知所有的等待在这个同步对象上的线程，你们可以苏醒过来了，有机会重新占用当前对象了。
  wait()、notify()、notifyAll()三个方法必须在synchronized代码块中使用