JAVA基础复习（七）多线程和网络

1、创建线程和任务，如：

​
//任务类必须实现Runnable接口
public class TaskClass implements Runnable{
 ...
      public TaskClass(...){
      ...
      }
      //想要在该线程执行的任务
      public void run(){
      ...
      }
...
}
//调用,run方法会被自动调用，无需特意调用它
...
public void someMethod(){

      TaskClass task1=new TaskClass(...);
      TaskClass task2=new TaskClass(...);

      Thread thread1=new Thread(task1);
      Thread thread2=new Thread(task2);

      thread1.start();
      thread2.start();
}
...

​

2、因为Thread类实现了Runnable，所以可以定义一个Thread的拓展类，并且实现run方法，但是不推荐这种方法，它将任务和运行任务的机制混在了一起，将任务从线程中分离出来是比较好的设置。

3、Thread类包含为任务而创建的线程的构造方法以及控制线程的方法，start()启动线程使方法run()被调用、isAlive测试线程当前是否正在运行、setPriority()设置线程的优先级0~10、join()等待线程结束、sleep()指定线程睡眠数，有一个必检异常、yield()使线程暂停并运行执行其他线程、interrupt()中断线程。

4、线程池是管理并发执行任务个数的理想方法，提供了Executor接口来执行线程池中的任务，提供ExecutorService接口来管理和控制任务。如：

import java.util.concurrent.*;

public class ExecutorDemo{
  //在线程池中创建3个线程，如果改成1，三个任务将顺序执行，如果默认不填则所有任务都并发地执行
  ExecutorService executor=Executors.newFixedThreadPool(3);

  //执行任务
  executor.execute(task1);
  executor.execute(task2);
  executor.execute(task3);

  //关闭线程池,但所有任务都将继续执行直至完成
  executor.shutdown();
}

5、如果一个共享资源被多个线程同时访问，可能会遭到破坏，即竞争状态，线程不安全。为了避免竞争状态，应该防止多个线程同时进入某一特定部分，程序中的这部分被称为临界区。调用一个对象的同步实例方法要求给该对象加锁，调用一个类的同步静态方法要求对该类加锁。当执行一个方法中某一个代码块时，同步语句不仅可用于对this对象加锁，而且可用于对任何对象加锁。这个代码块称为同步代码块synchronized（隐式加锁）,而一个锁是Lock接口的实例，它定义了加锁和释放锁的方法（显示加锁【lock()、unlock()、newCondition()返回绑定到Lock实例的新的Condition实例】,ReentrantLock是为创建相互排斥的锁Lock的具体实现，可以创建具有特定的公平策略的锁，真正公平的策略确保等待最长的线程首先获得锁）：

//任何同步实例方法都可以转化为同步语句
synchronizied(expr){
   statements;
}

public synchronized void someMethod(...){

}

//任务执行类
public static class Tasking implements Runnable{
      //线程里执行的操作
      public void run(){
             TaskClass task=new TaskClass();
             task.someMethod(...);
      }

}
//加锁操作类
public static class TaskClass(){

privite static Lock lock=new ReentrantLock();//创建一个锁

public void someMethod(...){
      lock.lock();//加锁
      try{
      //执行操作
      ...
     }catch(InterruptedException ex){

     }finally{
     lock.unlock();//释放锁
  }
 }

}

6、通过保证在临界区上多个线程的相互排斥，线程同步完全可以避免竞争状态的发生，但是有时候还需要线程之间的相互协作。一个线程可以指定在某种条件下该做什么，条件是通过调用Lock对象的newCodition()方法而创建的对象，一旦创建了条件，就可以使用（await()可以让当前线程都出于等待状态，直到条件发生、signal()唤醒一个等待的线程、signalAll()方法唤醒所有等待的线程)来实现线程之间的相互通信。

7、监视器是一个相互排斥且具备同步能力的对象，监视器中的一个时间点，只能有一个线程执行方法。任意对象都可能是一个监视器，一旦一个线程锁住对象，该对象就成为监视器。其中（这三个方法类似第六点上的三个方法）wait()、notify()和notifyAll()方法必须在这些方法的接收对象的同步方法或同步代码块中调用。

8、信号量可以用来限制访问共享资源的线程数，为了创建信号量，必须使用可选择的公平策略来确定许可的数量，Semaphore类携带两个构造方法，和acquire()获取这个信号量的许可、release()释放一个许可给该信号量。【只有一个许可的信号量可以用来模拟一个互斥的锁】

9、有时两个或多个线程需要在几个共享对象上获取锁，这可能会导致死锁，使用一种名为资源排序的简单技术可以轻易避免死锁的发生，该技术是给一个需要锁的对象指定一个顺序，确保每个线程都按这个顺序来获取锁。

10、线程的状态：新建、就绪、运行、阻塞或结束

11、可以通过锁定集合或者同步集合保护集合的数据，Collections类提供了六个静态方法将集合转换成同步版本【synchronizedCollection、synchronizedList、synchronizedMap、synchronizedSet、synchronizedSortedMap、synchronizedSortedSet】，这些同步类包装都是线程安全的，但是迭代器具有快速失败的特性。需要创建一个集合对象，并且在遍历它时获取对象上的锁。

Set hashSet=Collections.synchronizedSet(new HashSet());

synchronized(hashSet){
    Iterator iterator=hashSet.iterator();
    
    while(iterator.hasNext()){
          System.out.println(iterator.next());
   }
}

12、网络在为小程序进行前后台交互时使用较多，和诸多字符串、Json、字节流以及网络工具包配合使用

13、基于流的通信使用传输控制协议TCP【无损可靠】进行数据传输，基于包的通信使用用户数据报协议UDP