第12篇-JAVA 多线程

最新推荐文章于 2023-01-10 15:51:24 发布
最新推荐文章于 2023-01-10 15:51:24 发布
阅读量334 收藏
点赞数
分类专栏： JAVA-Markdown 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JEEP911/article/details/77101780
版权

第12篇-JAVA 多线程

  • 每篇一句 ：不要只看到艰难，要看艰难后面的胜利
  • 初学心得： 敢于尝试，就等于你已经向成功迈出了第一步
  • (笔者：JEEP/711)[JAVA笔记 | 时间:2017-04-20| JAVA 多线程 ]

目录导航

1.进程与线程

1.什么是进程
- 程序是指令和数据的有序的集合，其本身没有任何运行的含义，是一个静态的概念
- 进程是一个具有一定独立功能的程序，一个实体
- 几乎所有的操作系统都支持同时运行多个任务，一个任务通常就是一个程序，每个运行中的程序就是一个进程
- 当一个程序运行时，内部可能包含了多个顺序执行流，每个顺序执行流就是一个线程

2.进程的状态： 进程执行时的间断性，决定了进程可能具有多种状态，事实上，运行中的进程具有
- 以下三种基本状态：
- 1.就绪状态(Ready)
- 2.运行状态(Running)
- 3.阻塞状态(Blocked)

3.线程
- 线程实际上是进程基础之上的进一步划分，一个进程启动之后，里面的若干程序，又可以划分成若干个线程
- 线程:是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换
- 并发执行，一个进程最少有一个线程(单线程程序)

4.线程实现的两种方式
- 在java中如果想要实现多线程操作，两种实现方法
- 1.一种是继承Thrcad类
- 2.另一种是实现Runnable接口

5.多线程编程的优势
- 进程间不能共享内存，但线程之间共享内存非常容易
- 系统创建进程需要为该进程重新分配系统资源，但创建线程则代价小得多，因此使用多线程来实现多任务并发比多进程的效率高
- Java语言内置的多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了Java的多线程编程

2.继承Thread类创建线程类

（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就是代表了线程需要完成的任务
因此，我们经常把run方法称为线程执行体
（2）创建Thread子类的实例，即创建了线程对象
（3）调用线程对象的start方法来启动该线程
（4）join线程：Thread提供了让一个线程等待另一个线程完成的方法：join() 方法
当在某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到被join方法加入的join线程完成为止
join()方法通常由使用线程的程序调用，以将大问题划分成许多小问题，每个小问题分配一个线程。当所有的小问题都得到处理后，再调用主线程来进一步操作

3.实现Runnable接口创建线程类

（1）定义Runnable接口的实现类，并重写该接口的run方法，该run方法的方法体同样是该线程的线程执行体
（2）创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象
（3）调用线程对象的start方法来启动该线程

4.线程睡眠

如果我们需要让当前正在执行的线程暂停一段时间，并进入阻塞状态
则可以通过调用Thread类的静态sleep方法，sleep方法有两种重载的形式：
- static void sleep(long millis)：让当前正在执行的线程暂停millis毫秒，并进入阻塞状态，该方法受到系统计时器和线程调度器的精度和准确度的影响
- static void sleep(long millis, int nanos)：让当前正在执行的线程暂停millis毫秒加nanos毫微妙，并进入阻塞状态，该方法受到系统计时器和线程调度器的精度和准确度的影响

5.两种线程方式的对比

采用实现Runnable接口方式的多线程：
- 线程类只是实现了Runnable接口，还可以可以继承其他类
- 在这种方式下，可以多个线程共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况
- 从而可以将CPU，代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想
- 劣势：编程稍稍复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法

采用继承Thread类方式的多线程：
- 劣势：因为线程类已经继承了Thread类，所以不能再继承其他父类
- 优势：编写简单，如果需要访问当前线程,无需使用Thread.currentThread()方法,直接使用this即可获得当前线程

6.线程生命周期

线程声明周期：
- 就绪状态
- 执行状态
- 阻塞状态

7.线程安全问题

多条线程并发修改共享资源就容易引发线程安全问题
使用同步解决多线程共享数据出现安全问题
多个线程有可能同时处理同一个资源
线程同步就是指多个线程在同一个时间段内只能有一个线程执行指定代码
其他线程等待此线程完成之后才可以继续执行
同步代码块synchronized(要同步对象){要同步的操作}
同步方法public synchronized void method(){要同步的操作}
同步代码会带来性能降低的问题，提高数据的安全性，牺牲性能来保证安全
同步代码块
Java的多线程支持引入了同步监视器来解决这个问题，使用同步监视器的通用方法就是同步代码块
synchronized后括号里的obj就是同步监视器，上面代码的含义是：线程开始执行同步代码块之前，必须先获得对同步监视器的锁定
同步方法
Java的多线程安全支持还提供了同步方法，同步方法就是使用synchronized关键字来修饰某个方法，则该方法成为同步方法
对于同步方法而言，无需显式指定同步监视器，同步方法的同步监视器是this，也就是该对象本身
线程死锁
过多的同步有可能死锁，死锁的操作一般是在程序运行的时候才有可能出现
多线程中要进行资源的共享，就需要同步，但同步过多，就可能造成死锁

8.线程创建启动实例

package cn.jeep;
//继承Thread类
public class XianChengDemo extends Thread{
  private int i;//私有成员属性
  //重写run方法，run方法的方法体就是线程执行体
  public void run(){
      for(;i<100;i++){
          //当线程类继承Thread类时，直接使用this.及格获取当前线程
          //Thread对象的getNname()返回当前线程名字
          //因此可以直接调用getName方法返回当前线程名字
          System.out.println(getName()+" "+i);
      }
  }
  //主方法入口
  public static void main(String[] args) {
      for(int i=0;i<100;i++){
          //调用Thread的currenTread方法获取当前线程
          System.out.println(Thread.currentThread().getName()+" "+i);
          if(i == 20){
              //创建并启动第一个线程
              new XianChengDemo().start();
              //创建并启动第二个线程
              new XianChengDemo().start();    
          }
      }
  }
}
package cn.runnable;
//声明一个类
public  class RunnableDenmo implements Runnable{
  private int i;//私有属性
  //重写run方法
  public void run(){
      for(;i<100;i++){
          //当线程类实现Runnable接口时
          //如果想获取当前线程，只能用Thread.currentTread()方法
          System.out.println(Thread.currentThread().getName()+" "+i);
      }
  }
  //主方法
  public static void main(String[] args) {
      for(int i=0;i<100;i++){
          System.out.println(Thread.currentThread().getName()+" "+i);
          if(i == 20){
              RunnableDenmo st = new RunnableDenmo();
              //通过new Thread(target，name)方法创建新线程
              new Thread(st,"新线程1").start();
              new Thread(st,"新线程2").start();
          }
      }
  }
}
package cn.callable;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class CallableDemo {
  public static void main(String[] args) {
      //创建Callable对象
      @SuppressWarnings("unused")
      CallableDemo cl = new CallableDemo();
      //先使用Lambda表达式创建Callable<Integer>对象
      //使用FutureTask来包装Callable对象
      FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>)()->{
          int i = 0;
          for(;i<100;i++){
              System.out.println(Thread.currentThread().getName()+"的循环变量的i的值:"+i);
          }
          //call()方法可以有返回值
          return i;
      });
      for(int i=0;i<100;i++){
          if(i==20){
              //实质还是以Callable对象来创建并启动线程
              new Thread(task,"有返回值得线程").start();
          }
      }
      try{
      //获取线程返回值
      System.out.println("子线程的返回值:"+task.get());
          }catch(Exception ex){
      ex.printStackTrace();
      }
  }
}

9.线程同步实例

package cn.tongbu;
public class TB {
  public static void main(String[] args) {
      TbDemo tb = new TbDemo(); 
      Thread t1 = new Thread(tb,"小明");
      Thread t2 = new Thread(tb,"小白");
      Thread t3 = new Thread(tb,"小红");
      Thread t4 = new Thread(tb,"小黑");
      Thread t5 = new Thread(tb,"小华");
      t1.start();
      t2.start();
      t3.start();
      t4.start();
      t5.start();
  }
}
class TbDemo implements Runnable{
  Object obj = new Object();//同步得标记
  @Override
  public void run() {
      //线程同步代码块
      //synchronized(obj){
      //}
      say();//调用同步方法
  }
  /**
   * 同步方法
   */
  public synchronized void say(){
      System.out.println(Thread.currentThread().getName()+"正在通话中....");
      try {
          Thread.sleep(2000);//2秒
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
      System.out.println(Thread.currentThread().getName()+"通话结束！");
  }
}

10.线程死锁实例

package cn.sisuo;
public class SiSuoDemo {
  public static void main(String[] args) {
      new Ss();
  }
}
//警
class XingJing{
  //同步方法
  public synchronized void say(FeiTu f){
      System.out.println("警方说先放人质，在实行抓捕");
      f.dos();
  }
  public synchronized void dos(){
      System.out.println("同意匪徒要求，在实行抓捕");
  }
}
//匪徒
class FeiTu{
  //同步方法
  public synchronized void say(XingJing x){
      System.out.println("匪徒说先找一辆车，在放人质");
      x.dos();
  }
  public synchronized void dos(){
      System.out.println("先找一辆车，再放人质");
  }
}
/**
 * 死锁线程
 * @author JEEP-711
 *
 */
class Ss implements Runnable{
  XingJing xj = new XingJing();
  FeiTu ft = new FeiTu();
  //模拟线程死锁构造方法
  public Ss(){
      new Thread(this).start();//为了快速实现
      ft.say(xj);
  }
  @Override
  public void run() {
      xj.say(ft);
  }
}

11.多线程同步银行取钱实例

package cn.chinabank;//中国银行包
//声明一个账户类
public class Account {
  private String name;//私有属性-姓名
  private double number=0.0;//私有属性-余额
  //构造方法并传值
  public Account(String name,double number){
      this.name = name;//当前姓名
      this.number = number;//当前金额
  }
  //取得getName方法
  public String getName() {
      return name;
  }
  //设置setName方法
  public void setName(String name) {
      this.name = name;
  }
  //取得getNumber方法
  public double getNumber() {
      return number;
  }
  //设置setNumber方法
  public void setNumber(double number) {
      this.number = number;
  }
}
package cn.chinabank;//中国银行包
import java.util.Scanner;
//声明一个中国银行类
public class ChinaBank {
  //定义主方法
  public static void main(String[] args) {
      @SuppressWarnings("resource")
      Scanner sc = new Scanner(System.in);//接收控制台键盘输入
      System.out.println("----------------------");
      System.out.println("----欢迎您进入中国银行-----");
      System.out.println("---请选择您需要办理的业务---");
      System.out.println("1.存款"+"\t"+" 2.取款"+"\t"+"3.退出");
      System.out.println("----------------------");
      int sr = sc.nextInt();//接收一个数
      //接收用户输入
      switch(sr){
      //输入1则进入存款功能
          case 1:
               System.out.println("请您输入存款金额:");//提示用户存款金额
              double  number = sc.nextDouble();//接收用户输入金额
              @SuppressWarnings("unused")
              Account account1 = new Account("asdd",number);//创建Accound对象
              System.out.println("请您将钞票叠整齐后放入存钞口..");//提示用户将钞票放入存钞口
              try{
                  Thread.sleep(2000);//模仿现实银行存钞，设置睡眠时间两秒
                  System.out.println("正在存钞,请稍后...");//将输出等待
                  Thread.sleep(4000);//将其过程等待四秒
                  System.out.println("存款成功!");//则输出存款成功
          System.out.println("您的存款金额为:"+number+"\t"+"当前账户余额为:"+number);
                                                              //输出存款金额
          System.out.println("1.是否打印凭条"+"\t"+"2.是否继续存款"+"\t"+"3.退出");
                                                            //用户继续选择
                  int sr1 = sc.nextInt();//接收用户输入
                  switch(sr1){
                  //接收用户是否打印凭条
                      case 1:
                          System.out.println("dce");
                          System.out.println("打印完成,退出打印");
                          break;
                      //接收用户是否继续存款
                      case 2:
                          System.out.println("继续存款");
                          banking();
                          break;
                      //接收用户退出
                      case 3:
                          System.out.println("您已退出存款选项");
                          break;
                      //防止随意输入    
                      default :
                          System.out.println("您输入有误,请重新输入");
                          break;
                  }
              }catch(Exception e){
                  e.printStackTrace();
              }
              break;
          //输入2则进入取款功能    
          case 2:System.out.println("请输出您的取款金额:");
              Account account2 = new Account("小明",7000);//创建Account对象并传参数
              DrawMoney ka = new DrawMoney(account2,3000);//创建银行卡取款3000元
              DrawMoney zhe = new DrawMoney(account2,4000);//创建存折取款2000元
              new Thread(ka).start();//开启银行卡线程
              new Thread(zhe).start();//开启存折线程
              break;
          //输入3则退出银行系统
          case 3:
              System.out.println("您已安全退出中国银行系统,感谢您的光临!");
              System.exit(0);//退出指令
              break;
          //防止用户随意输入则进行友情提示
          default :
              System.out.println("您输入有误,请重新输入");
              break;
      }
  }
  //继承存款金额
  public static void banking(){
      @SuppressWarnings("resource")
      Scanner sc2 = new Scanner(System.in);//接收控制台键盘输入
               System.out.println("请您输入存款金额:");//提示用户存款金额
              double  number = sc2.nextDouble();//接收用户输入金额
              @SuppressWarnings("unused")
              Account account2 = new Account("asdd",number);//创建Accound对象
              System.out.println("请您将钞票叠整齐后放入存钞口..");//提示用户将钞票放入存钞口
              try{
                  Thread.sleep(2000);//模仿现实银行存钞，设置睡眠时间两秒
                  System.out.println("正在存钞,请稍后...");//将输出等待
                  Thread.sleep(4000);//将其过程等待四秒
                  System.out.println("存款成功!");//则输出存款成功
          System.out.println("您的存款金额为:"+number+"\t"+"当前账户余额为:"+number);
                                                       //输出存款金额
                  System.out.println("1.是否打印凭条"+"\t"+"\t"+"2.退出");//用户继续选择
                  int sr3 = sc2.nextInt();//接收用户输入
                  switch(sr3){
                  //接收用户是否打印凭条
                      case 1:
                          System.out.println("dce");
                          System.out.println("打印完成,退出打印");
                          break;
                      case 2:
                          System.out.println("您已退出存款选项");
                          break;
                      //防止随意输入    
                      default :
                          System.out.println("您输入有误,请重新输入");
                          break;
                  }
              }catch(Exception e){
                  e.printStackTrace();
              }   
  }
} 
package cn.chinabank;//中国银行包
//取钱类实现Runnable接口
public class DrawMoney implements Runnable{
  private Account account;//私有属性-账户
  private double money;//私有属性-金额
  //构造方法并传值
  public DrawMoney(Account account,double money){
      this.account = account;//当前账户
      this.money = money;//当前金额
  }
  @Override
  public void run() {
      while(true){
          //线程同步块
          //相当于将account队形锁住，只有执行完代码块，才可以释放，其他线程才能拿到
          //account必须是同一个
          synchronized(account){
              //如果账户金额大于等于金额
              if(account.getNumber()>=money){
                  account.setNumber(account.getNumber()-money);//账户余额减去取款金额
                  //输出取款成功，并显示当前账户剩余金额
                  System.out.println("你已取款成功,您取款金额为:"+money+"元,剩余金额为:"+account.getNumber()+"元");
                  //异常处理
                  try{
                  Thread.sleep(2000);//调用方法设置睡眠两秒
                  }catch(InterruptedException e){
                      e.printStackTrace();
              }
              //否则提示取款不成功,显示当前账户余额
              }else{
                  System.out.println("对不起，您的账户余额不足,您当前账户余额剩余"+account.getNumber()+"元");//输出账户金额
              }
          }
          break;
      }   
  }

12.多线程 - 生产者与消费者应用案例

多线程的开发中有一个最经典的操作案例，就是生产者-消费者
生产者不断生产产品，消费者不断取走产品

/**
* 生产者与消费者应用案例
* sleep与wait区别
* sleep让当前的线程进入休眠状态，让出cpu，让其他线程执行
* 如果用同步的话，有对象锁的时候，是不会释放的，只能等待此线程使用完，才可以使用
* wait会释放对象锁，必须等待其他线程唤醒
* @author JEEP-711
*
*/
public class ScXf {
  public static void main(String[] args) {
      Phones p = new Phones(null, null);//创建Phones对象
      PhoneSc s = new PhoneSc(p);//创建PhoneSc对象 
      PhoneXf x = new PhoneXf(p);//创建PhoneXf对象
      new Thread(s).start();//启动生产者线程
      new Thread(x).start();//启动消费者线程
  }
}
/**
 * 手机生产者，单独的生产者，实现Runnable接口
 * @author JEEP-711
 *
 */
class PhoneSc implements Runnable{
  private Phones phones;
  public PhoneSc(Phones phones){
      this.phones = phones;
  }
  @Override
  public void run() {
      //不断地生产20份，生产的过程
      for (int i = 0; i < 50; i++) {
          if(i%2==0){
              phones.set("金立手机", "金立手机，中国造!");
          }else{
              phones.set("小米手机", "小米手机,为发烧而生!");
          }
      }
  }
}
/**
* 手机消费者，顾客
 * @author JEEP-711
 *
 */
class PhoneXf implements Runnable{
  private Phones phones;
  public PhoneXf(Phones phones){
      this.phones = phones;
  }
  @Override
  public void run() {
      for (int i = 0; i < 50; i++) {
          phones.get();//调用消费产品方法
      }
  }
}
/**
* 产品的对象，生产的手机
* @author JEEP-711
*
 */
class Phones{
  @Override
  public String toString() {
      return "Phones [name=" + name + ", content=" + content + "]";
  }
  private String name;
  private String content;
  /**true表示可以生产，false表示可以消费
   * 作为标记，如何flag等于true表示可以生产，如何flag等于false表示不可生产
   * 如果flag等于false表示可以消费状态，可以取走，flag等于true表示不能取走
   * 解决重复值得问题
   */
  private boolean flag = true;//表示可以生产，false表示可以消费
  //构造方法
  public Phones(String name, String content) {
      super();
      this.name = name;
      this.content = content;
  }
  //取得名称方法
  public String getName() {
      return name;
  }
  //设置名称方法
  public void setName(String name) {
      this.name = name;
  }
  //取得内容方法
  public String getContent() {
      return content;
  }
  //设置内容方法
  public void setContent(String content) {
      this.content = content;
  }
  /**
   * 通过同步，解决了取值错误问题
   * @param name
   * @param content
   */
  //生产制造同步方法
  public synchronized void set(String name, String content){
      if(!flag){
          try {
          //调用该方法，当前线程进入等待池等待状态，没有指定时间，
          //需要其他线程唤醒，释放对象锁，让出cpu
              this.wait();
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
      this.setName(name);
      try {
          Thread.sleep(300);
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
      this.setContent(content);
      flag = false;//表示可以消费，取走
      this.notify();//唤醒在该监视器上的一个线程
  }
  //消费产品同步取值方法
  public synchronized void get(){
      if(flag){
          try {
              //调用该方法，当前线程进入等待池等待状态，没有指定时间，
              //需要其他线程唤醒，释放对象锁，让出cpu
              this.wait();
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
      try {
          Thread.sleep(300);
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
      System.out.println(this.getName()+":"+this.getContent());
      flag = true;
      this.notify();
  }
}

13.线程池

线程池是预先创建线程的一种技术，线程池在还没有任务到来之前，创建一定数量的线程，放入空闲队列中，然后对这些资源进行复用，减少频繁的创建和销毁对象
java里面线程池的顶级接口是Executor，是一个执行线程的工具
线程池接口是ExecutorServise
1.java.util.concurrent包：并发编程中很常用的实用工具包
2.Executor接口：执行已提交Runnable任务的对象

ExecutorService接口：
Executor提供了管理终止的方法，以及可能为跟踪一个或
多个异步任务执行状况而发生的Future的方法
Executors类：此包中所定义的Executor、ExecutorService等的工厂和实现方法
在Executors类里提供了一些静态工厂，生成一些常用的线程池
newSingleThreadExecutor：
创建一个单线程的线程池，这个线程池只有一个线程在工作，也就是相当于单线程
串行执行所有的任务，如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它，此线程池保证所有任务的执行顺序按照任务的提交顺序执行
newFixedThreadPool：
创建固定大小的线程池，每次提交一个任务就创建一个线程，直到线程达到线程池的最大线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程
newCacheadThreadPool：
创建一个可缓存的线程池，如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲(60秒不执行)的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务，此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统(或者说jvm)能够创建的最大线程大小
newSchediledThreadPool：
创建一个大小无限制的线程池，此线程池支持定时以及周期性执行任务需求

使用线程池的步骤：
- （1）调用Executors类的静态工厂方法创建一个ExecutorService对象或ScheduledExecutorService对象，其中前者代表简单的线程池，后者代表能以任务调度方式执行线程的线程池
- （2）创建Runnable实现类或Callable实现类的实例，作为线程执行任务
- （3）调用ExecutorService对象的submit方法来提交Runnable实例或Callable实例；或调用ScheduledExecutorService的schedule来执行线程
- （4）当不想提交任何任务时调用ExecutorService对象的shutdown方法来关闭线程池

初学(JAVA 多线程 高级阶段) 难点: ★★★★★

希望每一篇文章都能够对读者们提供帮助与提升，这乃是每一位笔者的初衷

感谢您的阅读 欢迎您的留言与建议

anonymous-system
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Thread&ThreadPool、Parallel、Async和Await用法总结
weixin_30502965的博客
07-06 205
1、线程和线程池Thread&ThreadPool //线程初始化时执行方法可以带一个object参数，为了传入自定义参数，所以执行需单独调用用于传参。 Console.WriteLine("执行线程"); Thread th = new Thread((objParam) => { Console.WriteLine("线...
异步多线程之Parallel详解
菜鸟厚非
12-19 1万+
Parallel 叫做并行编程 .Net 4.5 时代的，基于 Task 基础上做了封装。Parallel 的特点方便控制线程并发数量与节省一个线程。
性能优化系列之-普通的Thread多线程改为Java8的parallelStream并发流
cicuiling6750的博客
08-27 1364
概括总结 Java8的parallelStream并发流能达到跟多线程类似的效果，但它也不是什么善茬，为了得到跟上一版本的多线程类似的效果，一改再改，虽然最后改出来了，但是还是存在理解不了的地方。 怎样得到一个parallelStream 理论上，你需要先有一个List&lt...
Thread-parallel
weixin_38866327的博客
05-12 223
6-6 jmu-Java-07多线程-同步访问 (10 分)
m0_54524462的博客
12-02 3249
6-6 jmu-Java-07多线程-同步访问 (10 分) 现已有Account类，拥有 属性: private int balance 方法: 相应的getter方法。 要求为该类编写： void deposit(int money) //存钱，在余额的基础上加上money void withdraw(int money) //取钱，在余额的基础上减去money 注意： 取钱时如果balance<0的时候，会抛出异常。在多线程情况下，如只有一个存钱的线程，但是有多个取钱的线程，很可能会抛出异常。
Java面试题总结 - Java多线程篇（附答案）
学Java，找哪吒
05-30 2万+
一、线程的run()和start()有什么区别？ 每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，run()方法称为线程体。通过调用Thread类的start()方法来启动一个线程。 start() 方法用于启动线程，run() 方法用于执行线程的运行时代码。run() 可以重复调用，而 start() 只能调用一次。 start()方法来启动一个线程，真正实现了多线程运行。调用start()方法无需等待run方法体代码执行完毕，可以直接继续执行其他的代码； 此时线程..
Java多线程（超详细！）
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
万字图解Java多线程
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
java8 第七章-----多线程
Xiayebuliang的博客
01-10 2427
进程（Process）是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。线程（Thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行。单核 CPU 下，线程实际还是 串行执行 的。
计算机后端-Java-Java核心基础-第19章 IDEA的使用与多线程 12. 多线程的优点等.avi
05-22
计算机后端-Java-Java核心基础-第19章 IDEA的使用与多线程 12. 多线程的优点等.avi
Java多线程继承Thread类详解第1/2页
09-02
在Java编程中，多线程是并发处理任务的关键技术，它使得程序可以同时执行多个不同的任务，提高系统的效率和响应速度。Java提供了两种主要的多线程实现方式：继承`Thread`类和实现`Runnable`接口。本文将详细讲解继承...
java多线程设计模式详解(PDF及源码)
07-14
去睡觉吧 第11章 Thread-Specific Storage——每个线程的保管箱 第12章 Active Object——接受异步消息的主动对象 总结 多线程程序设计的模式语言 附录A 练习问题的解答 附录B Java的内存模型 附录C Java线程的...
第12周-Java：Java练习（Java镇）
02-18
在本主题"第12周-Java：Java练习（Java镇）"中，我们将深入探讨Java编程语言的一些关键概念和实战技巧。这个练习模块被称为"Java镇"，寓意着我们将在Java的世界里进行一系列的实践操作，以巩固和增强我们的编程能力...
java第12章java-chapter12.rar
最新发布
06-26
第12章的学习通常会涵盖Java的一些高级特性或特定主题，如多线程、网络编程、I/O流、集合框架、异常处理等。以下是基于这个章节可能涉及的一些关键知识点的详细解释： 1. **多线程**：Java提供了一种并发执行任务的...
第6篇-JAVA面向对象Ⅱ
JEEP/711 Blog
06-05 1079
第6篇-JAVA面向对象Ⅱ 每篇一句 ：敢于向黑暗宣战的人，心中必定充满光明 初学心得： 面向对象 春暖花开 (笔者：JEEP/711)[JAVA笔记 | 时间:2017-04-05| JAVA面向对象 Ⅱ] 目录导航第6篇-JAVA面向对象 目录导航 JAVA面向对象三大特征 面向对象 之 封装 面向对象 之 继承 面向对象 之 多态 初学面向对象三大特征 难点 希望每一篇文章都能够对
第14篇-JAVA GUI编程
JEEP/711 Blog
08-12 870
第14篇-JAVA GUI编程 每篇一句 ：道路一开始开辟的时候总是存在障碍的 初学心得： 原本下定决心才能开始的事情也变得理所当然 (笔者：JEEP/711)[JAVA笔记 | 时间:2017-04-25| JAVA GUI编程 ] 目录导航第14篇-JAVA GUI编程 目录导航 什么是界面 Java 基础类 JFC 的基本概念 什么是组件Component 什么是容器Container 什么
第5篇-JAVA面向对象Ⅰ
JEEP/711 Blog
06-05 728
第5篇-JAVA面向对象Ⅰ 每篇一句 ：面向对象面向君，不负代码不负卿 初学心得： 代码虐我千百遍，我待代码如初恋 (笔者：JEEP/711)[JAVA笔记 | 时间:2017-04-03| JAVA面向对象 Ⅰ] 目录导航第5篇-JAVA面向对象 目录导航 JAVA作为一种面向对象语言具有以下基本概念 面向对象 JAVA类和对象 static关键字 new关键字 匿名对象 对象的引用 thi
第4篇-JAVA基础
JEEP/711 Blog
06-05 587
第4篇-JAVA基础 每篇一句 ：世界上本没有完美，但是我们从未放弃追求完美 初学心得： 乐于挥霍的时间，都不能算作浪费 (笔者：JEEP/711)[JAVA笔记 | 时间:2017-04-01| JAVA基础 Ⅳ] 目录导航第4篇-JAVA基础 目录导航 程序运行流程 顺序结构 分支结构 循环结构 break 与 continue关键字 数组 方法 初学基础难点 希望每一篇文章都能够对读者

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值