Java基础之线程

最新推荐文章于 2024-03-10 23:38:03 发布
最新推荐文章于 2024-03-10 23:38:03 发布
阅读量928 收藏 1
点赞数 1
分类专栏： 基础增强 文章标签： java thread string class 多线程 join
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuchangqing123/article/details/7525980
版权

1.   线程

2.   用Thread类创建线程：继承Thread类后重写run方法，在主函数中创建出该类后调用start方法启动线程

publicclass ThreadDemo1 {
   publicstaticvoid main(String[] args) {
      new TestThread().start();
      while(true){
         System.out.println("main():" + Thread.currentThread().getName());//打印出当前线程类的名称
      }
   }
 
}
class TestThread extends Thread{
   publicvoid run(){
      while(true){
         System.out.println("run():" + Thread.currentThread().getName());
      }
   }
}

3.   前台线程和后台线程：如果是前台线程比如上面的TestThread，则main主线程结束的时候，TestThread线程仍然在执行；如果是后台线程，则前台线程结束后，后台线程也会结束；如下：

publicclass ThreadDemo1 {
   publicstaticvoid main(String[] args) {
//    new TestThread().start();
      Thread aa = new TestThread();
      aa.setDaemon(true);
      aa.start();
      /*while(true){
         System.out.println("main():"+ Thread.currentThread().getName());//打印出当前线程类的名称
      }*/
   }
 
}
class TestThread extends Thread{
   publicvoid run(){
      while(true){
         System.out.println("run():" + Thread.currentThread().getName());
      }
   }
}

4.   联合线程：

publicclass ThreadDemo1 {
   publicstaticvoid main(String[] args) {
      // new TestThread().start();
      Thread aa = new TestThread();
      // aa.setDaemon(true);
      aa.start();
      int index = 0;
      while (true) {
         if (index++ == 200){
            try {
                aa.join();// 将aa线程合并到主线程中，之后aa线程在执行，主线程在等待；也可以在join方法中指定合并线程的时间
            } catch (InterruptedExceptione) {
                e.printStackTrace();
            }
         }
         System.out.println("main():" + Thread.currentThread().getName());// 打印出当前线程类的名称
      }
   }
 
}
 
class TestThread extends Thread {
   publicvoid run() {
      while (true) {
         System.out.println("run():" + Thread.currentThread().getName());
      }
   }
}

5.   利用runnable接口实现Thread

public class ThreadDemo1 {
   public static void main(String[] args) {
      // new TestThread().start();
      Thread aa = new Thread(newTestThread());
      // aa.setDaemon(true);
      aa.start();
      int index = 0;
      while (true) {
         if (index++ == 200){
            try {
                aa.join(1000);// 将aa线程合并到主线程中，之后aa线程在执行，主线程在等待；也可以在join方法中指定合并线程的时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
         }
         System.out.println("main():" + Thread.currentThread().getName());// 打印出当前线程类的名称
      }
   }
 
}
 
class TestThread implements Runnable {
   publicvoid run() {
      while (true) {
         System.out.println("run():" + Thread.currentThread().getName());
      }
   }
}

6.   使用runnable接口实现的线程比继承Thread类实现的线程灵活得多：

public class ThreadDemo1 {
	public static void main(String[] args) {
		// new TestThread().start();
		Thread aa = new TestThread();
		// aa.setDaemon(true);
		aa.start();
		aa.start();
		aa.start();

	}

}

class TestThread extends Thread {
	int tickets = 100;

	public void run() {
		while (true) {
			if(tickets > 0)
			System.out.println("run():" + Thread.currentThread().getName()
					+ "is saling ticket" + tickets--);
		}
	}
}

上面的代码中只是启动了一个线程；

public class ThreadDemo1 {
   public static void main(String[] args) {
      // new TestThread().start();
      TestThread aa = new TestThread();
      // aa.setDaemon(true);
      new Thread(aa).start();
      new Thread(aa).start();
      new Thread(aa).start();
      new Thread(aa).start();
   }
 
}
 
class TestThreadimplements Runnable {
   inttickets = 100;
 
   publicvoid run() {
      while (true) {
         if(tickets > 0)
         System.out.println("run():" + Thread.currentThread().getName()
                + "is saling ticket" + tickets--);
      }
   }
}

7.   使用runnable接口可以实现几块代码同时处理相同的资源，所以这种用法使用比较多；

8.   多线程的应用：网络聊天程序，将发信息和接受信息放置到两个线程中执行；

9.   多线程的同步问题：问题的出现

public class ThreadDemo1 {
   public static void main(String[] args) {
      // new TestThread().start();
      TestThread aa = new TestThread();
      // aa.setDaemon(true);
      new Thread(aa).start();
      new Thread(aa).start();
      new Thread(aa).start();
      new Thread(aa).start();
   }
 
}
 
class TestThreadimplements Runnable {
   inttickets = 100;
 
   publicvoid run() {
      while (true) {
         if(tickets > 0){
            try {
                Thread.sleep(10);
            } catch (InterruptedExceptione) {
                //TODO Auto-generated catch block
                e.printStackTrace();
            }
         System.out.println("run():" + Thread.currentThread().getName()
                + "is saling ticket" + tickets--);
         }
      }
   }
}

通过睡眠10毛秒就会发生线程的同步问题，这样就会出现卖通一张票的问题；同步问题就是解决代码的原子性问题；

10.同步问题的解决：通过同步语句块实现（synchronized）

public class ThreadDemo1 {
   public static void main(String[] args) {
      // new TestThread().start();
      TestThread aa = new TestThread();
      // aa.setDaemon(true);
      new Thread(aa).start();
      new Thread(aa).start();
      new Thread(aa).start();
      new Thread(aa).start();
   }
 
}
 
class TestThreadimplements Runnable {
   inttickets = 100;
   String str = new String("");
   publicvoid run() {
      while (true) {
         synchronized (str) {
            if(tickets > 0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                //TODO Auto-generated catch block
                e.printStackTrace();
            }
         System.out.println("run():" + Thread.currentThread().getName()
                + "is saling ticket" + tickets--);
         }
        }
        
      }
   }
}

通过对象的标志位进行标识，使当前的同步代码块在同一时刻只能被一个线程调用；注意同步代码块的实现是使用监视器对象实现的，所以监视器对象的创建不能在run方法中，否则不同的线程就会拥有自己的监视器对象无法达到同步的目的；

11.通过同步方法实现：将可能发生同步问题的代码抽取到同步方法中实现

public class ThreadDemo1 {
   public static void main(String[] args) {
      // new TestThread().start();
      TestThread aa = new TestThread();
      // aa.setDaemon(true);
      new Thread(aa).start();
      new Thread(aa).start();
      new Thread(aa).start();
      new Thread(aa).start();
   }
 
}
 
class TestThreadimplements Runnable {
   inttickets = 100;
 
   publicvoid run() {
      while (true) {
            sale();
 
      }
   }
 
   privatesynchronizedvoid sale() {
      if (tickets > 0) {
         try {
            Thread.sleep(10);
         } catch (InterruptedException e) {
            //TODO Auto-generated catch block
            e.printStackTrace();
         }
         System.out.println("run():" + Thread.currentThread().getName()
                + "is saling ticket" + tickets--);
      }
   }
}

12.同步代码块影响程序的执行效率

13.线程start之后只是说明当前的线程处于启动状态，不一定立即执行；代码的顺序不一定是线程启动的顺序；

14.验证同步方法所使用的监视器对象是this，实现代码块和方法的同步；

public class ThreadDemo1 {
   public static void main(String[] args) {
      // new TestThread().start();
      TestThread aa = new TestThread();
      // aa.setDaemon(true);
      new Thread(aa).start();
      try {
         Thread.sleep(1);
      } catch (InterruptedException e) {
         // TODO Auto-generated catchblock
         e.printStackTrace();
      }
      aa.str = "method";
      new Thread(aa).start();
      new Thread(aa).start();
      new Thread(aa).start();
   }
 
}
 
class TestThreadimplements Runnable {
   inttickets = 100;
   String str = new String("");
 
   publicvoid run() {
 
      if (str.equals("method")) {
         while(true){
         sale();
         }
      } else {
         while (true) {
            synchronized (this) {
                if (tickets > 0) {
                   try {
                      Thread.sleep(10);
                   } catch (InterruptedException e) {
                      //TODO Auto-generated catch block
                      e.printStackTrace();
                   }
                   System.out.println("run():"
                         + Thread.currentThread().getName()
                         + "is saling ticket" + tickets--);
                }
 
            }
         }
      }
   }
 
   privatesynchronizedvoid sale() {
      if (tickets > 0) {
         try {
            Thread.sleep(10);
         } catch (InterruptedException e) {
            //TODO Auto-generated catch block
            e.printStackTrace();
         }
         System.out.print("sale ");
         System.out.println("run():" + Thread.currentThread().getName()
                + "is saling ticket" + tickets--);
      }
   }
}

15.线程的死锁问题

public class ThreadDemo1 {
   public static void main(String[] args) {
      // new TestThread().start();
      TestThread aa = new TestThread();
      // aa.setDaemon(true);
      new Thread(aa).start();
      try {
         Thread.sleep(1);
      } catch (InterruptedException e) {
         //TODO Auto-generated catch block
         e.printStackTrace();
      }
      aa.str ="method";
      new Thread(aa).start();
      new Thread(aa).start();
      new Thread(aa).start();
   }
 
}
 
class TestThreadimplements Runnable {
   inttickets = 100;
   String str = new String("");
 
   publicvoid run() {
 
      if (str.equals("method")) {
         while(true){
         sale();
         }
      } else {
         while (true) {
            synchronized (str) {
                if (tickets > 0) {
                   try {
                      Thread.sleep(10);
                   } catch (InterruptedException e) {
                      //TODO Auto-generated catch block
                      e.printStackTrace();
                   }
                   synchronized (this) {
                     
                   }
                   System.out.println("run():"
                         + Thread.currentThread().getName()
                         + "is saling ticket" + tickets--);
                }
 
            }
         }
      }
   }
 
   privatesynchronizedvoid sale() {
      if (tickets > 0) {
         try {
            Thread.sleep(10);
         } catch (InterruptedException e) {
            //TODO Auto-generated catch block
            e.printStackTrace();
         }
 
         synchronized (str) {
 
         }
         System.out.print("sale ");
         System.out.println("run():" + Thread.currentThread().getName()
                + "is saling ticket" + tickets--);
      }
   }
}

16.线程间的通信：生产者和消费者之间的关系，生产者生产一个产品消费者才能消费一个产品；

class Producer implements Runnable {
   Q q;
 
   public Producer(Q q) {
      this.q = q;
 
   }
 
   @Override
   publicvoid run() {
      int i = 0;
      while (true) {
         synchronized (q) {
            if(q.bFull){
                try {
                   q.wait();
                } catch(InterruptedException e) {
                   // TODO Auto-generatedcatch block
                   e.printStackTrace();
                }
            }
            if (i == 0) {
               q.name ="zhangsan";
                try {
                   Thread.sleep(1);
                } catch (InterruptedException e) {
                   //TODO Auto-generated catch block
                   e.printStackTrace();
                }
                q.sex ="male";
            } else {
                q.name ="lisi";
                q.sex ="female";
            }
            i = (i + 1) % 2;
            q.bFull =true;
            q.notify();
           
         }
      }
 
   }
 
}
 
class Consumerimplements Runnable {
 
   Q q;
 
   public Consumer(Q q) {
      this.q = q;
   }
 
   @Override
   publicvoid run() {
      while (true) {
         synchronized (q) {
           if(!q.bFull){
                try {
                   q.wait();
                } catch(InterruptedException e) {
                   // TODO Auto-generatedcatch block
                   e.printStackTrace();
                }
            }
            System.out.print(q.name);
            System.out.println(" : " +q.sex);
            q.bFull =false;
            q.notify();
         }
      }
 
   }
 
}
 
class Q {
   String name;
   String sex;
   Boolean bFull =false;
}
 
publicclass ThreadCommunation {
   publicstaticvoid main(String[] args) {
      Q q = new Q();
      new Thread(new Producer(q)).start();
      new Thread(new Consumer(q)).start();
 
   }
 
}

以上的代码中将q作为共同的监视器，解决了同步问题；为了解决线程多次访问同一个资源使用了线程间的通信；通过q.wait()方法将当前的线程置入等待状态，释放cpu的使用权；使用q.notify()方法通知其他线程启动；

将以上代码进行优化后的代码：

class Producer implements Runnable {
   Q q;
 
   public Producer(Q q) {
      this.q = q;
 
   }
 
   @Override
   publicvoid run() {
      int i = 0;
      while (true) {
         synchronized (q) {
            if (i == 0) {
                q.put("zhangsan","male");
            } else {
                q.put("lisi","female");
            }
            i = (i + 1) % 2;
         }
      }
 
   }
 
}
 
class Consumerimplements Runnable {
 
   Q q;
 
   public Consumer(Q q) {
      this.q = q;
   }
 
   @Override
   publicvoid run() {
      while (true) {
         synchronized (q) {
            q.get();
         }
      }
 
   }
 
}
 
class Q {
   private Stringname;
   private Stringsex;
   private BooleanbFull = false;
   public synchronized voidput(String name, String sex) {
      if (bFull) {
         try {
            wait();
         } catch (InterruptedException e){
            // TODO Auto-generated catchblock
            e.printStackTrace();
         }
      }
 
      this.name = name;
      try {
         Thread.sleep(1);
      } catch (InterruptedException e) {
         // TODO Auto-generated catchblock
         e.printStackTrace();
      }
      this.sex = sex;
      bFull = true;
      notify();
 
   }
 
   public synchronized voidget() {
      if (!bFull) {
         try {
            wait();
         } catch (InterruptedException e){
            // TODO Auto-generated catchblock
            e.printStackTrace();
         }
      }
      System.out.print(name);
      System.out.println(" : "+ sex);
      bFull = false;
      notify();
   }
 
}
 
publicclass ThreadCommunation {
   publicstaticvoid main(String[] args) {
      Q q = new Q();
      new Thread(new Producer(q)).start();
      new Thread(new Consumer(q)).start();
 
   }
 
}

上面的代码是将对Q类的处理都抽象为自己的方法，同时这些方法都是线程安全的，更加符合面向对象的思想；

liuchangqing123
关注
专栏目录
Java基础之线程游戏
08-03
本文将深入探讨“Java基础之线程游戏”，基于提供的源码和相关博客文章，我们将一起学习Java线程的基本概念、如何创建和管理线程，以及在实际开发中的应用。 线程是操作系统分配CPU时间的基本单元，它允许程序并发...
【后端】 java基础（5.8）java高级基础之线程——synchronized关键字
03-29
java基础（5.8）java高级基础之线程——synchronized关键字 本章主要讲线程，至于带上进程的原因是为了方便大家对进程和线程有个概念（咳，主要原因是鄙人也不太会进程~）。 首先简单说下我个人对进程和线程的理解。...
Java 基础 —— 线程安全
IT__learning的博客
10-31 9008
一、线程安全问题 线程安全 当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象就是线程安全的 一个程序在运行起来的时候会转换成进程，通常含有多个线程。通常情况下，一个进程中的比较耗时的操作（如长循环、文件上传下载、网络资源获取等），往往会采用多线程来解决。又比如实际生活中，银行取钱问题、火车票多个售票窗口的问题，通常会涉及到并发的问题，从而需要多线程的技术。 当进程中
Java基础之线程实现的三种方式
李长渊的博客
12-19 2005
Java基础之线程实现的三种方式
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6319
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
java基础之线程安全问题（二）
weixin_50691399的博客
11-07 2388
本文主要是解决Java多线程安全问题的第二种方法
Java多线程（超详细！）
热门推荐
一只小菜鸡
05-13 13万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
最新发布
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java基础知识总结（2021版）
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
JAVA之线程FutureTask
gong_mengmeng的博客
06-23 3175
java线程FutureTask的使用
Java基础多线程.xmind
09-20
个人关于java基础多线程的思维导图总结。0积分下载。如果认为有帮助，请关注点赞，日后还有更多免费资源。
Java基础之多线程
08-26
以下是对Java多线程基础知识点的详细解释： 1. **线程启动与执行**： - `start()` 方法用于启动线程，将线程放入操作系统的线程队列等待CPU调度执行，调用后会自动执行`run()` 方法。 - `run()` 方法是线程的主要...
java线程基础
12-21
Java线程基础是Java编程中不可或缺的一部分，尤其在开发高并发和实时响应的应用时更为重要。线程允许程序同时执行多个任务，提高了程序的效率和响应速度。 **应用程序与进程** 应用程序是用户可以执行的软件实例，...
Java IO输入输出流
长青树呀
05-07 1322
1.   File类是代表文件信息的类，而不是文件的内容 public class FileTest { public static void main(String[] args) { File f = new File("1.txt"); if(f.exists()){ f.delete(); }else{ try
Java基本语法注意事项
长青树呀
05-01 1136
1.   以下是Java基本语法 2.   Java是大小写敏感的 3.   注释的写法问题 4.   布尔常量只能是true或者false 5.   null为常量，表示该变量的引用为空 6.   要特别注意在强制类型转换的数据精度丢失问题 7.   byte、short、char类型的变量赋值给int时会发生自动的类型转换； 8.   分析System.out.println(‘
Java基础之Java开发环境的基本设置
长青树呀
05-01 1022
1.   设置环境变量，在命令行窗口中利用set命令查看环境变量，如果查看特定的一个环境变量则键入类似set path的命令即可； 2.   在已有的环境变量的后面追加内容的方法：%path%；\aaa 3.   注意在设置环境变量的时候set path=。。。其中=的前后都不能有空格，否则系统将会把空格+path看成一个变量； 4.   在运行java程序的时候，系统首先在环境变量path
Java零基础自学：线程详解
"Java线程基础教程，涵盖了线程的概念、生命周期、实现方式、优先级、同步和线程组等内容，适合Java初学者学习。" 在计算机编程中，特别是Java语言，线程是一个非常重要的概念，它允许程序在同一时间执行多个独立的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值