java中的多线程——进度2

java中的多线程——进度2
多线程总结：

1，进程和线程的概念。
   |--进程：是一块包含了某些资源的内存区域。操作系统利用进程把它的工作划分为一些功能单元；

　　最小的内存单元；

　　　　　　是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的独立单元；

   |--线程：线程只能属于一个进程并且它只能访问该进程所拥有的资源，当操作系统建一个进程后，该进程会自动申请一个主要线程或者首要线程；

　　　　　　线程是进程的一个实体，是cpu调度和分派的基本单位，他是比进程更小的能独立运行的基本单位
　　　　　　线程基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器，一组寄存器和栈）

　　　　　　线程可以和同属一个进程中的其他线程共享进程拥有的全部资源；
2，jvm中的多线程体现。
   |--主线程，垃圾回收线程，自定义线程。以及他们运行的代码的位置。

3，什么时候使用多线程，多线程的好处是什么？创建线程的目的？
   |--当需要多部分代码同时执行的时候，可以使用。

4，创建线程的三种方式。★★★★★
   |--继承Thread
       |--步骤
public class ThreadDemo extends Thread{ run(){ thread.sleep(); } }
View Code
　 |--实现Runnable

|--步骤
1 public class ThreadDemo implements Runnable{ 2 @Overate 3 run(){ 4 Thread.sleep() 5 } 6 }
View Code
　

　 |--实现Callable

|--步骤
```
public class CallableThreaTest implements Callable<Integer>{
public static void main(String[] args){
CallableThreadTest ctt = new CallableThreadTest();
FutureTask<Integer> ft = new FutureTask<>(ctt);
for(int i=0; i<100;i++)
{
System.out.println(Thread.currentThread().getName()+i);
if(i==20)
{
    new Thread(ft,"有返回值的线程").start();
}
}
try{
system.out.println("子线程的返回值:”+ft.get());
}catch(InterruptedException e){
e.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}

}  
@Override
public Integer call() throws Exception
{
int i=0;
for(;i<100;i++)
{
    System.out.println(Thread.currentThread().getName()+""+i);
}
return i;
}
}
```
|--两种方式的区别？
　　1.Thread类本身也是实现了Runnable的接口的run方法

　　2.Runnable对共享资源的同步性能更好

　　3.Runnable解决了单继承的问题
5，线程的5种状态。

   对于执行资格和执行权在状态中的具体特点。
   |--被创建（new）：new Thread(r)

    |--就绪（Runnable）：已经被调用start（）方法但是还没有获得系统资源
   |--运行：就绪状态的线程具备执行资格和执行权，开始执行run方法

   |--阻塞（Block）：具备执行资格还不具备执行权，线程没有运行结束临时让出了cpu

    　　|--阻塞的原因：调用sleep方法；调用了一个在IO上被阻塞的操作；没有获得锁；等待某个触发条件，

　　　　　　其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

   |--消亡（dead）：run方法正常退出了；一个未捕获的异常终止了run方法而使线程猝死。

    |--锁池：被锁定，同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。

    |--等待队列：wait（），等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
6，线程的调度

　　6.1线程的优先级

　　Java线程的优先级用整数表示，取值范围是1~10

　　|--static int MAX_PRIORITY线程可以具有的最高优先级，取值为10。

　　|--static int MIN_PRIORITY 线程可以具有的最低优先级，取值为1。

　　|--static int NORM_PRIORITY 分配给线程的默认优先级，取值为5。

　　6.2线程睡眠

　　线程睡眠：Thread.sleep(long millis)方法，使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。sleep()平台移植性好。

　　6.3线程等待

　　线程等待：Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象的notify() 方法或 notifyAll() 唤醒方法。这个两个唤醒方法也是Object类中的方法，行为等价于调用 wait(0) 一样。

　　sleep()和yield()的区别

　　sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。

　　 sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU  的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程
       另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield()  方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 IO 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。

　　wait和sleep区别

　　共同点：
　　1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。
　　2. wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException。

　　不同点：

　　1. Thread类的方法：sleep(),yield()等
   　　Object的方法：wait()和notify()等
　　2. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。
   　　sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
　　3. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
　　4. sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
　　所以sleep()和wait()方法的最大区别是：
　　　　sleep()睡眠时，保持对象锁，仍然占有该锁；
　　　　而wait()睡眠时，释放对象锁。
　　但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException（但不建议使用该方法）。

　　6.4线程让步

　　线程让步：Thread.yield() 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。

　　yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

　　yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。可看上面的图。

　　6.5线程加入

　　join()方法，等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。

　　join是Thread类的一个方法，启动线程后直接调用，即join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了，join()方法后面的代码，只有等到子线程结束了才能执行。

　　在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

　　6.6线程唤醒

　　线程唤醒：Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。类似的方法还有一个notifyAll()，唤醒在此对象监视器上等待的所有线程。

7.线程的同步

   |--安全问题的原因：当一个线程在执行操作共享数据多条代码过程中，其他线程参与了运算。
   |--解决的思想：隔离共享资源
   |--解决的体现：synchronized
   |--同步的前提：但是加上同步还出现安全问题，就需要用前提来思考。
   |--同步的两种表现方法和区别：1.线程代码块的同步synchronized（锁为具体对象）；2.方法的同步（锁为this）；
   |--同步的好处和弊端：
   |--单例的懒汉式。
public class SingleInstance{ private static final singleInstance = new Single(); private SingleInstance(){} public void getInstance(){ return singleInstance; } }
恶汉式
```
//牛逼枚举类实现安全单例模式
public Enum Single{
　　SINGLEINSTANCE
　　public void getInstance(){
　　　　return 　　SINGLEINSTANCE;
}
}
```
public class SingleInstance{ private static singleInstance = null; private SingleInstance(){} public static synchronized SingleInstance getInstance(){ if(singleInstance ==null){//解决效率问题 synchronized(singleInstance .class) if(singleInstance ==null) s=new singleInstance; return s; } }
懒汉式
|--死锁：两个线程互相持有对方需要的资源，呈现一种僵局。
8.线程之间的数据传递

在传统的同步开发模式下，当我们调用一个函数时，通过这个函数的参数将数据传入，并通过这个函数的返回值来返回最终的计算结果。但在多线程的异步开发模式下，数据的传递和返回和同步开发模式有很大的区别。由于线程的运行和结束是不可预料的，因此，在传递和返回数据时就无法象函数一样通过函数参数和return语句来返回数据。
　　8.1通过构造方法传递数据

　　在创建线程时，必须要建立一个Thread类的或其子类的实例。因此，我们不难想到在调用start方法之前通过线程类的构造方法将数据传入线程。并将传入的数据使用类变量保存起来，以便线程使用(其实就是在run方法中使用)。下面的代码演示了如何通过构造方法来传递数据：
```
public class Thread1 extends Thread{
private String name;
public Thread1(String name){
this.name = name;
}
public void run(){
System.out.println(name);
}
```
```
public static void main(String[] args) 
{ 
Thread thread = new MyThread1("world"); 
thread.start(); 
} 
```
```
}
```
由于这种方法是在创建线程对象的同时传递数据的，因此，在线程运行之前这些数据就就已经到位了，这样就不会造成数据在线程运行后才传入的现象。如果要传递更复杂的数据，可以使用集合、类等数据结构。使用构造方法来传递数据虽然比较安全，但如果要传递的数据比较多时，就会造成很多不便。由于Java没有默认参数，要想实现类似默认参数的效果，就得使用重载，这样不但使构造方法本身过于复杂，又会使构造方法在数量上大增。因此，要想避免这种情况，就得通过类方法或类变量来传递数据。(类似Spring中的构造注入)

　　8.2.通过变量和方法传递数据

　　向对象中传入数据一般有两次机会，第一次机会是在建立对象时通过构造方法将数据传入，另外一次机会就是在类中定义一系列的public的方法或变量（也可称之为字段）。然后在建立完对象后，通过对象实例逐个赋值。下面的代码是对MyThread1类的改版，使用了一个settName方法来设置 name变量：
```
public class MyThread2 implements Runnable 
{ 
private String name; 
public void setName(String name) 
{ 
this.name = name; 
} 
public void run() 
{ 
System.out.println("hello " + name); 
} 
public static void main(String[] args) 
{ 
MyThread2 myThread = new MyThread2(); 
myThread.setName("world"); 
Thread thread = new Thread(myThread); 
thread.start(); 
} 
} 
```
　　8.3通过回调函数传递数据

　　上面讨论的两种向线程中传递数据的方法是最常用的。但这两种方法都是main方法中主动将数据传入线程类的。这对于线程来说，是被动接收这些数据的。然而，在有些应用中需要在线程运行的过程中动态地获取数据，如在下面代码的run方法中产生了3个随机数，然后通过Work类的process方法求这三个随机数的和，并通过Data类的value将结果返回。从这个例子可以看出，在返回value之前，必须要得到三个随机数。也就是说，这个 value是无法事先就传入线程类的。
```
class Data
{
public int value = 0;
}
class Work
{
public void process(Data data,Integer numbers)
{
for(int n:numbers)
{
data.value+=n;
}    
}


public calss Thread2 extends Thread
{
private Work work;
public Thread3(Work work)
{
this.work = work;
}
}
public void run() 
{ 
java.util.Random random = new java.util.Random(); 
Data data = new Data(); 
int n1 = random.nextInt(1000); 
int n2 = random.nextInt(2000); 
int n3 = random.nextInt(3000); 
work.process(data, n1, n2, n3); // 使用回调函数 
System.out.println(String.valueOf(n1) + "+" + String.valueOf(n2) + "+" 
+ String.valueOf(n3) + "=" + data.value); 
} 
public static void main(String[] args) 
{ 
Thread thread = new MyThread3(new Work()); 
thread.start(); 
} 
}
```
9，停止线程的方式。
|--原理：1.exit线程正常退出；2.Thread.stop产生无法预料的结果;3Interrupt()不会停止正在运行的线程;
|--表现：--中断。
相关阅读:
centos8 安装postresql12
vs code 开启远程调试步骤
 node 版本管理器 nvs
Vue I18n Vue.js 的国际化插件+elementUI的使用
 c#结构
 下拉菜单
 使用Convert 类和Parse方法将字符串转换为数值类型
 c# try..... catch
c#迭代算法
 网页兼容各种浏览器
原文地址：https://www.cnblogs.com/jinb/p/6209129.html