第36节：Java当中的线程

àì夳堔傛蜴生んèń 2021-09-16 06:32 376阅读 0赞

![标题图][1240]

## Java当中的线程 ##

`Java`当中的线程，进程和线程的关系？进程就是线程吗？不是的。线程的运行，和方法。

**多线程和多进程，多进程为在操作系统中同时进行多个应用程序，**如你的电脑可以同时听音乐，同时上网，手机也可以，所以也就是多进程，原理上这些都是由`cpu`执行的，因为`cpu`执行很快，执行一个应用然后执行别的应用程序，然后再次回来执行，速度很快。（则`cpu`在进程中快速地来回切换）

多线程则是在一个应用程序中多个顺序流同时执行，线程就是执行任务，可以理解在一款软件中，同时执行任务，可以这么理解，多线程举例一边干嘛，一边又做别的。

## 线程的执行过程 ##

一个应用程序，至少有一个`Thread`线程。

一个应用程序，可以有多个线程，由于线程之间执行（跳来跳去执行）切换特别快，所以我们误会，仿佛很多线程同时执行。

## 创建线程的方法 ##

**第一种：**

定义一个线程类，将该类继承`Thread`类，然后重写其中的方法`run()`，在`Java`中是只支持单继承的，所以不能再继承其他类了。

class MyThread extends Thread{ 
     public void run(){
      System.out.println("dashucoding");
     }
    }
    class Demo{ 
     public static void main(String args[]){
      // 创建线程对象
      MyThread my = new MyThread();
     // 启动线程
     my.start();
     }
    }

在`Java`代码运行中，如果没有用`start()`开启线程，就只有一个主线程，那么就一个线程，此时就不是多线程了。

**第二种：**

实现线程，可以定义一个类去实现接口`Runnable`，作为线程的目标对象，初始化`Thread`类或者`Thread`子类的线程对象，把对象传递给线程实例，然后由对象提供线程体。

class MyRunnable implements Runnable{ 
     public void run(){
     ...
     }
    }
    class Demo{ 
     public static void main(String args[]){
      // 创建Runnable接口实现类的对象
     Runnable r=new Runnable();
     // 创建Thread对象，将Runnable接口实现类的对象作为参数，传递给Thread对象
     Thread t = new Thread(r);
     // 调用start()方法，开启线程
     t.start();
     }
    }

## 线程的一些方法 ##

**一般常用的方法**

public static void sleep(long millis)；
    public static void sleep(long millis, int nanos)；
    Thread.sleep(); // 睡眠
    Thread.yield(); // 让出cpu
    getPriority(); // 获取优先级
    setPriority(); // 设置优先级
    public Thread();
    public Thread(Runnable target);
    public Thread(Runnable target, String name);
    public Thread(String name);
    public Thread(ThreadGroup group, String name);
    public Thread(ThreadGroup group, Runnable target);
    public Thread(ThreadGroup group,Runnable target, String name);
    public void destroy(); ：破坏线程
    public void interrupt(); ：中断线程运行
    public final int getPriority(); ：返回线程优先级
    public final String getName(); ：返回线程的名字
    public final void setName(String name); ：设置线程名
    public final void setPriority(int newPriority); ：设置线程优先级

## 多线程的安全，同步线程的方法 ##

获取线程名字

Thread.currentThread().getName()

线程安全引入同步代码块`synchronized`

class MyThread implements Runnable{ 
     int i = 10;
     public void run(){
      while(true){
       // Thread.currentThread().getName()
      System.out.println(Thread.currentThread().getName()+i);
      i--;
      Thread.yield();
      if(i<0){
      break;
      }
      }
     }
    }

**加锁格式：**

class MyThread implements Runnable{ 
     int i = 10;
     public void run(){
      while(true){
       synchronized(this){
       // Thread.currentThread().getName()
      System.out.println(Thread.currentThread().getName()+i);
      i--;
      Thread.yield();
      if(i<0){
      break;
      }
      }
      }
     }
    }

## synchronized关键字 ##

`synchronized`锁住的什么呢？同步代码块的作用，同步方法的作用。锁住的是对象。

class Service{ 
     public void fun(){
      synchronized(this){
       try{
        Thread.sleep(3*1000);
       }catch(Exception e){
        System.out.println(e);
       }
      }
     }
     public void fun2(){
      synchronized(this){
       System.out.println("dashucoding");
      }
     }
    } 
    
    // 线程
    class MyThread1 implements Runnable{ 
     private Service service;
     public MyThread1(Service service){
      this.service = service;
     }
     public void run(){
      service.fun1();
     }
    }
    // 线程
    class MyThread2 implements Runnable{ 
     private Service service;
     public MyThread2(Service service){
      this.service = service;
     }
     public void run(){
      service.fun2();
     }
    }
    // 测试
    class Test{ 
     public static void main(String args[]){
      Service service = new Service();
      Thread t1 = new Thread(new MyThread1(service));
      t1.start();
      Thread t2 = new Thread(new MyThread2(service));
      t2.start();
     }
    }

线程在程序中是顺序执行的指令序列，多线程则是在程序中并发执行多个指令序列，线程是比进程小的执行单位，一个进程可以有多个线程，每个线程有自己的产生，存在和消亡的过程。

`MIN_PRIORITY`，`MAX_PRIORITY`和`NORMAL_PRIORITY`，分别代表：线程最低、最高和普通优先级的常量，优先级等级分别为1、10和5。

## 线程的同步与死锁 ##

在同一进程中会有很多个线程，这些线程共同享受一个存储空间，这样就有个访问冲突的问题，**有两个线程同时访问一个对象时，一个线程用来向对象存储数据，一个用来读取数据。**

这时就遇到问题了，当这个线程还没有完成存储的操作，另一个线程就开始读取数据了，就会产生错误，这时在`java`线程中采用了同步机制，这样就不会出错了，因为只有一个线程完成它的操作之前，其他线程是不允许操作的。`Java`语言引入关键字`synchronized`，有两种方法：`synchronized`方法（解决同步的问题，但也有缺陷）和`synchronized`块。

synchronized(syncObject){
       //允许访问控制的代码
    }

#### 线程的死锁 ####

在`Java`中，线程同步解决了对象访问的冲突，但是同样带来了问题，就是线程的死锁，什么是线程死锁呢？

**举个例子：**一个线程拥有对象`A`，另一个线程拥有对象`B`，但是第一个线程必须拥有对象`B`才能继续，同时第二个线程必须拥有对象`A`才能继续。两个线程都在相互等待对方释放当前的对象，导致两个线程阻塞，发送了线程的死锁。

## 结语 ##

*  下面我将继续对`Java`、 `Android`中的其他知识 深入讲解 ，有兴趣可以继续关注
 *  小礼物走一走 or 点赞

[1240]: /images/20210724/22b51540037f4df48389176836504e46.png