关键词：
1.1，多线程的作用:
*线程是程序执行的一条路径, 一个进程中可以包含多条线程
*多线程并发执行可以提高程序的效率, 可以同时完成多项工作
1.2，多线程的应用场景:
* 红蜘蛛同时共享屏幕给多个电脑
* 迅雷开启多条线程一起下载
* QQ同时和多个人一起视频
* 服务器同时处理多个客户端请求
1.3，线程并发与并行的区别：
* 并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。
* 并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
* 如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。
* 比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。
1.4，线程的生命周期:
新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();
就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；
运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就 绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；
阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：
1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
2.同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；
3.其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
1.5，线程的三种创建方式:
1.5.1，继承Thread类，重写run方法：
1 public class Demo01_Thread { 2 public static void main(String[] args) { 3 MyThread mh = new MyThread(); //4.创建Thread类的子类对象 4 mh.start(); //5.开启线程 5 } 6 } 7 class MyThread extends Thread{ //1.继承Thread 8 @Override 9 public void run() { //2.重写run方法 10 for (int i = 0; i < 10000; i++) { //3.将要执行的代码写在run方法中 11 System.out.println(getName+"继承线程已执行"+i); 12 } 13 } 14 }
如上图所示，创建MyThread实例进入新建状态，然后调用start（）方法启动，但是线程不一定会立马启动，因为要看cpu的资源分配
1.5.2，实现Runnable，重写run方法:
1 public static void main(String[] args) { 2 MyRunnable mr = new MyRunnable(); //4.创建Runnable中的子类实例 3 Thread tr = new Thread(mr); //将Runnable中的子类变量放入Thread类中 4 tr.start(); 5 } 6 } 7 class MyRunnable implements Runnable{ //1.定义类实现Runnable 8 9 @Override 10 public void run() { 11 for (int i = 0; i < 10000; i++) { //2.重写Run方法 12 System.out.println(Thread.currentThread().getName()+"Runnable中的线程执行:"+i); //3.将要执行代码写在run方法中 13 } 14 } 15 }
1.5.3，继承Thread与Runnable有什么区别:
源码的区别:
* a.继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
* b.实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法
总结的好处与坏处:
* 继承Thread * 实现Runnable接口
* 好处是:可以直接使用Thread类中的方法,代码简单 * 好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
* 弊端是:如果已经有了父类,就不能用这种方法 * 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂
1.6，实现Callable创建线程(了解就好，弊处代码太复杂一般不用):
1 // 创建线程池对象 2 ExecutorService pool = Executors.newFixedThreadPool(2); 3 4 // 可以执行Runnable对象或者Callable对象代表的线程 5 Future<Integer> f1 = pool.submit(new MyCallable(100)); 6 Future<Integer> f2 = pool.submit(new MyCallable(200)); 7 8 // V get() 9 Integer i1 = f1.get(); 10 Integer i2 = f2.get(); 11 12 System.out.println(i1); 13 System.out.println(i2); 14 15 // 结束 16 pool.shutdown(); 17 18 public class MyCallable implements Callable<Integer> { 19 20 private int number; 21 22 public MyCallable(int number) { 23 this.number = number; 24 } 25 26 @Override 27 public Integer call() throws Exception { 28 int sum = 0; 29 for (int x = 1; x <= number; x++) { 30 sum += x; 31 } 32 return sum; 33 } 34 35 }
上面是线程的作用，以及五种状态的详细讲解还有线程的创建方式，下面是对线程进行的一些操作。
1.7，多线程之同步代码块:
什么情况下需要同步？
* 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
* 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.
同步代码块？
* 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
* 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的
1.7.1，非静态方法使用锁让代码进行同步，锁对象可以是任意对象，只要相同就好:
1 class Printer { 2 Demo d = new Demo(); 3 public static void print1() { 4 synchronized(d){ //锁对象可以是任意对象,但是被锁的代码需要保证是同一把锁,不能用匿名对象 5 System.out.print("我"); 6 System.out.print("爱"); 7 System.out.print("程"); 8 System.out.print("序"); 9 System.out.print("员"); 10 System.out.print("\r\n"); 11 } 12 } 13 14 public static void print2() { 15 synchronized(d){ 16 System.out.print("噢"); 17 System.out.print("我"); 18 System.out.print("不"); 19 System.out.print("信"); 20 System.out.print("\r\n"); 21 } 22 } 23 }
1.7.2，静态方法使用锁，让代码进行同步:
1 class Printer { 2 public static void print1() { 3 synchronized(Printer.class){ //锁对象可以是任意对象,但是被锁的代码需要保证是同一把锁,不能用匿名对象 4 System.out.print("黑"); 5 System.out.print("马"); 6 System.out.print("程"); 7 System.out.print("序"); 8 System.out.print("员"); 9 System.out.print("\r\n"); 10 } 11 } 12 /* 13 * 非静态同步函数的锁是:this 14 * 静态的同步函数的锁是:字节码对象 15 */ 16 public static synchronized void print2() { 17 System.out.print("传"); 18 System.out.print("智"); 19 System.out.print("播"); 20 System.out.print("客"); 21 System.out.print("\r\n"); 22 } 23 }
1.8，多线程之多线程休眠(顾名思义就是休眠线程的):
* Thread.sleep(毫秒,纳秒), 控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000
1 public static void main(String[] args) { 2 new Thread(){ 3 @Override 4 public void run() { 5 for (int i = 0; i < 100; i++) { 6 try { 7 Thread.sleep(1000); 8 } catch (InterruptedException e) { 9 // TODO Auto-generated catch block 10 e.printStackTrace(); 11 } 12 System.out.println(getName()+"aaaaaaaaaaaa"); 13 } 14 } 15 }.start(); 16 new Thread(){ 17 @Override 18 public void run() { 19 for (int i = 0; i < 100; i++) { 20 try { 21 Thread.sleep(1000); 22 } catch (InterruptedException e) { 23 // TODO Auto-generated catch block 24 e.printStackTrace(); 25 } 26 System.out.println(getName()+"bb"); 27 } 28 } 29 }.start(); 30 } 31 }
1.9，多线程之守护线程:
*setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出
1 Thread t1 = new Thread() { 2 public void run() { 3 for(int i = 0; i < 50; i++) { 4 System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa"); 5 try { 6 Thread.sleep(10); 7 } catch (InterruptedException e) { 8 e.printStackTrace(); 9 } 10 } 11 } 12 }; 13 14 Thread t2 = new Thread() { 15 public void run() { 16 for(int i = 0; i < 5; i++) { 17 System.out.println(getName() + "...bb"); 18 try { 19 Thread.sleep(10); 20 } catch (InterruptedException e) { 21 e.printStackTrace(); 22 } 23 } 24 } 25 }; 26 27 t1.setDaemon(true); //将t1设置为守护线程 28 29 t1.start(); 30 t2.start();
2.0，多线程之加入线程:
* join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
* join(int), 可以等待指定的毫秒之后继续
1 final Thread t1 = new Thread() { 2 public void run() { 3 for(int i = 0; i < 50; i++) { 4 System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa"); 5 try { 6 Thread.sleep(10); 7 } catch (InterruptedException e) { 8 e.printStackTrace(); 9 } 10 } 11 } 12 }; 13 14 Thread t2 = new Thread() { 15 public void run() { 16 for(int i = 0; i < 50; i++) { 17 if(i == 2) { 18 try { 19 //t1.join(); //插队,加入 20 t1.join(30); //加入,有固定的时间,过了固定时间,继续交替执行 21 Thread.sleep(10); 22 } catch (InterruptedException e) { 23 24 e.printStackTrace(); 25 } 26 } 27 System.out.println(getName() + "...bb"); 28 29 } 30 } 31 }; 32 33 t1.start(); 34 t2.start();
2.1，多线程之礼让线程（了解）:
1 public static void main(String[] args) { 2 new MyTread().start(); 3 new MyTread().start(); 4 5 } 6 } 7 class MyTread extends Thread{ 8 @Override 9 public void run() { 10 for (int i = 0; i < 1000; i++) { 11 if(i % 10 == 0){ 12 Thread.yield();//让出cpu 13 } 14 System.out.println(getName()+"..."+i); 15 } 16 } 17 }
2.2，多线程之设置线程的优先级（了解）:
1 public static void main(String[] args) { 2 Thread t1 = new Thread(){ 3 public void run() { 4 for (int i = 0; i < 100; i++) { 5 System.out.println(getName()+"aaaaaaaaaaaaa\t\t\t"+i); 6 } 7 }; 8 }; 9 10 Thread t2 = new Thread(){ 11 public void run() { 12 for (int i = 0; i < 100; i++) { 13 System.out.println(getName()+"bb\t\t\t"+i); 14 } 15 }; 16 }; 17 // t1.setPriority(10); //设置最大优先级 18 // t2.setPriority(1); 19 t2.setPriority(Thread.MIN_PRIORITY); //最小 20 t1.setPriority(Thread.MAX_PRIORITY); //最大 21 t1.start(); 22 t2.start(); 23 } 24 }
2.3，多线程之死锁(了解)
* 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁
* 尽量不要嵌套使用
1 private static String s1 = "筷子左"; 2 private static String s2 = "筷子右"; 3 public static void main(String[] args) { 4 new Thread() { 5 public void run() { 6 while(true) { 7 synchronized(s1) { 8 System.out.println(getName() + "...拿到" + s1 + "等待" + s2); 9 synchronized(s2) { 10 System.out.println(getName() + "...拿到" + s2 + "开吃"); 11 } 12 } 13 } 14 } 15 }.start(); 16 17 new Thread() { 18 public void run() { 19 while(true) { 20 synchronized(s2) { 21 System.out.println(getName() + "...拿到" + s2 + "等待" + s1); 22 synchronized(s1) { 23 System.out.println(getName() + "...拿到" + s1 + "开吃"); 24 } 25 } 26 } 27 } 28 }.start(); 29 }
2.4，多线程(两个线程间的通信)(掌握)：
* 1.什么时候需要通信
* 多个线程并发执行时, 在默认情况下CPU是随机切换线程的
* 如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印
* 2.怎么通信
* 如果希望线程等待, 就调用wait()
* 如果希望唤醒等待的线程, 就调用notify();
* 这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用
1 public static void main(String[] args) { 2 MyThread mt = new MyThread(); 3 new Thread(){ 4 @Override 5 public void run() { 6 while(true){ 7 try { 8 mt.print1(); 9 } catch (InterruptedException e) { 10 // TODO Auto-generated catch block 11 e.printStackTrace(); 12 } 13 } 14 } 15 }.java高级开发技术学习笔记之多线程(代码片段)
暑假期间，个人对一些未来研究生阶段可能会常用的编程技术进行重新一轮的系统复习和学习，及希望能够查缺补漏，有所提升。本文也是作为复习和学习过程中的笔记，用于长久的记录。不排除其中可能含有部... 查看详情
java之多线程讲解
一、线程解析（1）线程的创建 1、继承Thread类创建线程类，代码如下：//1、定义一个继承Thread类的子类，并重写该类的run()方法；//2、创建Thread子类的实例，即创建了线程对象；//3、调用该线程对象的start()方法启动线程。clas... 查看详情
java之多线程
package com.yuanzijian01;/* * 线程通讯： 一个线程完成了自己的任务时，要通知另外一个线程去完成另外一个任务. 生产者与消费者wait(): 等待 如果线程执行了wait方法，那么该线程会进入等... 查看详情
java之多线程
/***测试Thread中的常用方法：*1.start():启动当前线程；调用当前线程的run()*2.run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中*3.currentThread():静态方法，返回执行当前代码的线程*4.getName():获取当前... 查看详情
java基础之多线程
一、线程基本知识1、线程与进程 进程：执行中的程序 线程：轻量级的进程 线程本身不能单独进行，必须放在一个进程中才能执行。2、Java的线程模型 1、新建状态 线程被创建之后便处于新建状态。... 查看详情
java之多线程的理解
线程的属性（1）线程的状态 线程在它的生命周期中可能处于以下几种状态之一：New（新生）：线程对象刚刚被创建出来；Runnable（可运行）：在线程对象上调用start方法后，相应线程便会进入Runnable状态，若被线程调度... 查看详情
java基础之多线程闭锁
1.闭锁方式1：利用CountDownLatch进行闭锁importjava.util.concurrent.CountDownLatch;publicclassCloseLock3{ publicstaticvoidmain(String[]args){ longstart=System.currentTimeMillis(); CountDownLatchlatch=newCountDow 查看详情
java之多线程二
一、JDK5之后的Lock锁的概述和使用package a;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class SellTicket implements Runnable 查看详情
java必会之多线程
一、线程的基本知识1.1线程知识进程和线程的关系和区别线程：线程是进程的基本执行单元，进程想要执行任务，必须要有线程。程序启动默认开启一条线程，这个线程被称为主线程。进程：进程是指在系统中正在运行的一个应... 查看详情
2022-08-02java之多线程
(目录)一、概念1.什么是多线程线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位，而多线程就是指从软件或者硬件上实现多个线程并发执行的技术，具有多线程能力的计算机因有硬... 查看详情
java之多线程
进程：正在执行的程序作为一个进程。进程负责了内存空间的划分问题：windows号称是多任务的操作系统，那么Windows是同事运行了多个程序吗 从宏观的角度：Windows确实实在同时运行了多个程序 从微观的角度：cpu... 查看详情
java面试之多线程
一、线程和进程之间的区别1.进程:一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的xx.exe就是一个进程。进程中的一个执行任务（控制单元），... 查看详情
java复习之多线程
线程是一个程序中的不同路径例子1只有一条路径每一个分支都是一个线程实际上在一个时刻内电脑只能运行一个进程但是因为cpu运算速度很快将时间分出来了所以我们感觉是同时运行创建线程的两种方式例子1：例子2：继承自thr... 查看详情
java之多线程窗口卖票问题(thread)
/****例子：创建三个窗口卖票，总票数为100张.使用继承Thread类的方式**存在线程的安全问题，待解决。**/classWindowextendsThread{privatestaticintticket=100;@Overridepublicvoidrun(){while(true){if(ticket>0){System.out.println(getName()+"：卖票，票号 查看详情
java面试之多线程篇
目录一、java中的线程分为几种？二、线程与进程的区别：三、什么是死锁？ 四、产生死锁的必要条件五、线程的五种状态六、为什么调用start()方法执行run()方法七、java中有几种方法可以实现一个线程？八、wait... 查看详情
java面试之多线程
35.并行和并发有什么区别？并行：多个处理器或多核处理器同时处理多个任务。并发：多个任务在同一个CPU核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。如下图：并发=两个队列和一台咖啡机。并行... 查看详情
java面试之多线程
35.并行和并发有什么区别？并行：多个处理器或多核处理器同时处理多个任务。并发：多个任务在同一个CPU核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。如下图：并发=两个队列和一台咖啡机。并行... 查看详情
java并发编程之多线程同步
线程安全就是防止某个对象或者值在多个线程中被修改而导致的数据不一致问题，因此我们就需要通过同步机制保证在同一时刻只有一个线程能够访问到该对象或数据，修改数据完毕之后，再将最新数据同步到主存中，使得其他... 查看详情