首页 / JAVA / JavaDay24 多线程与多进程

JavaDay24 多线程与多进程

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了JavaDay24 多线程与多进程，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含12208字，纯文字阅读大概需要18分钟。

内容图文

tags:

进程
线程

JavaDay24 多线程与多进程

@toc

代码示例：

package DemoDay24;

import org.junit.jupiter.api.Test;

/**使用线程实现同时视频和语音
 * @author GJXAIOU
 * @create 2019-07-24-20:54
 */

class VideoThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("视频中。。。。。");
        }
       
    }
}
class AudioThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("语音中。。。。。");
        }
        
    }
}

public class Demo1 {
    
    //方法一：使用main函数进行调试
//    public static void main(String[] args) {
//        VideoThread videoThread = new VideoThread();
//        AudioThread audioThread = new AudioThread();
//
//        videoThread.start();
//        audioThread.start();
//    }

    //方法二：使用JUnit中@test进行调试
    @Test
    public void test(){
        VideoThread videoThread = new VideoThread();
        AudioThread audioThread = new AudioThread();

        videoThread.start();
        audioThread.start();
    }

}

程序运行结果：
每次运行结果会不同，进程会别抢占；

语音中。。。。。
语音中。。。。。
语音中。。。。。
语音中。。。。。
语音中。。。。。
视频中。。。。。
视频中。。。。。
视频中。。。。。
视频中。。。。。
视频中。。。。。

一、线程中的常用方法

方法名	含义	说明
Thread(String name);	初始化线程的名字	属于线程的一个有参数的构造方法
setName(String name);	修改线程的名字
getName();	获取线程的名字
sleep();	static静态方法，通过Thread类名调用，这里需要处理一些异常，要求当前线程睡觉多少毫秒;	【哪一个线程执行了sleep方法，哪一个线程就睡觉】。
currentThead();	static静态方法，返回当前的线程对象;	【哪一个线程执行了currentThread方法，就返回哪一个线程对象】。
getPriority();	返回当前线程的优先级	CPU执行的优先级，不是绝对的，仅仅是提升概率。
setPriority(int newPriority);	设置线程的优先级。

【注意】
线程的优先级范围是从1 ~ 10， 10最高，1最低
这里的优先级只是提高了当前线程拥有CPU执行权的概率，并不能完全保证当前线程能够一定会占用更多的CPU时间片。线程的默认优先级为5。

Thread[main,5,main]
Thread[Thread-0,5,main]
Thread[线程名，优先级，线程组名]
线程中常见方法的测试：
run()方法中不能抛出异常，只能使用 try-catch

package DemoDay24;

/**
 * @author GJXAIOU
 * @create 2019-07-24-21:23
 */
public class Demo2 extends Thread {

    public Demo2(String name) {
        super(name);//调用父类Thread的有参构造方法
    }

    
    @Override
    public void run() {
        //这里是Demo2线程对象的线程代码
        System.out.println("28:" + Thread.currentThread());

        for (int i = 0; i < 5; i++) {
            System.out.println("自定义线程");
		/*
		 在其他方法中， 使用sleep方法，可以抛出，可以捕获，
		 但是在run方法为什么只有捕获没有抛出？因为这是一个语法规则：
		 在Java中，重写父类的方法，要求和父类的方法声明一模一样，
		 在Thread类中，run方法没有抛出异常，所以在子类中，你也不能抛出异常，要和父类一致
		 */
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //这里是main线程
        Demo2 d = new Demo2("狗蛋");

        d.setName("狗娃");
        d.setPriority(10);
        d.start(); //开启自定义线程，执行自定义线程中的run方法里面的功能
        System.out.println("39:" + Thread.currentThread());

        for (int i = 0; i < 5; i++) {
            System.out.println("这里是main线程");
            sleep(100);
        }
    }
}

程序运行结果：

39:Thread[main,5,main]
这里是main线程
28:Thread[狗娃,10,main]
自定义线程
这里是main线程
自定义线程
自定义线程
这里是main线程
这里是main线程
自定义线程
自定义线程
这里是main线程

下面的 InterfaceA 和 testA 是为了测试什么时候是不能使用抛出异常，只能使用 try-catch

package com.qfedu.a_thread;

interface A {
	public void testA();
}

public class Demo2 extends Thread implements A{
	public Demo2(String name) {
		super(name);//调用父类Thread的有参构造方法
	}
	
	@Override
	public void testA() {
		//这里也无法抛出异常，两种处理方法，第一种，捕获异常，
		//第二种，在接口中声明方法部分，声明该异常
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}	
	}
//--------------------------------------------------	
//下面代码省略
}

二、线程的生命周期

[外链图片转存失败(img-j6ZAToze-1568986092781)($resource/%E7%BA%BF%E7%A8%8B%E7%9A%84%E7%94%9F%E5%91%BD%E5%91%A8%E6%9C%9F.png)]

三、线程的共享资源问题

以动物园买票为示例：
一共有 50张票 3个窗口同时售卖
这里隐含多线程，这里可以把3个窗口看做是3个线程

第一次问题:
发现票每一张都被买了三次
- 原因：
  因为Ticket是在每一个线程中run方法里面的一个局部变量，这个局部变量是每一个线程对象都拥有的,这里Ticket就是不在是一个共享资源
- 处理方式：
  把Ticket变成成员变量
第二次问题：
发现貌似每一张票还都是卖了50次，而且这里还优化了售卖的算法
- 原因：
  这里Ticket变成了一个成员变量，在每一个线程对象中，都拥有这个Ticket成员变量，每一个成员变量是一个独立的个体，不是共享资源
- 处理方式:
  用static修饰ticket成员变量，变成一个存放在数据共享区的一个静态成员变量
第三次问题：
发现会出现几张票是买了多次的
- 原因：
  因为窗口1在卖票的时候，还没有运行到ticket–这条语句的时候，下一个窗口2开始执行卖票算法
  这里窗口2卖的票是窗口1还没有ticket–的票
  [外链图片转存失败(img-ArlJjEsh-1568986092782)($resource/%E7%BA%BF%E7%A8%8B%E5%AE%89%E5%85%A8%E9%97%AE%E9%A2%98.png)]
  处理方式：
  上锁，锁门
Java中的线程同步机制：
方式1：
同步代码块：

synchronized (锁对象) {
  //需要同步的代码;
}

同步代码块的注意事项：

锁对象，可以是任意的一个对象，但是必须是同一个对象！！！不能在这里使用new 来创建匿名对象
sleep() 不会释放锁对象，不会开锁。例如：厕所有人关门睡着了
使用synchronized 同步代码块的时候，必须是真正意义上存在共享资源的线程问题，才会使用
而且通常情况下，用synchronized锁住的代码越少越好，提高代码执行效率

package com.qfedu.a_thread;


class SaleTicket extends Thread {
  private static int ticket = 50;

	public SaleTicket(String name) {
		super(name);
	}

	@Override
	public void run() {

		while (true) {
			synchronized ("你好") { 
			//可以使用"你好 "的任何确定的对象 
			//不能使用new Demo3()创建不同对象，即对应不同的锁 
				if (ticket > 0) {
					System.out.println(Thread.currentThread().getName()+
					":卖出来第" + ticket+ "张票");
					try {
						sleep(500); //睡眠也不会释放锁对象
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				} else {
					System.out.println("卖完了");
					break;
				}

				ticket--;
			}
		}
	}
}

public class Demo3 {
	public static void main(String[] args) {
		SaleTicket s1 = new SaleTicket("窗口1");
		SaleTicket s2 = new SaleTicket("窗口2");
		SaleTicket s3 = new SaleTicket("窗口3");

		s2.start();
		s1.start();
		s3.start();

	}
}

程序运行结果：

窗口1:卖出来第50张票
窗口1:卖出来第49张票
。。。。。
窗口3:卖出来第28张票
窗口3:卖出来第27张票
窗口3:卖出来第26张票
窗口3:卖出来第2张票
窗口3:卖出来第1张票
卖完了
卖完了
卖完了

（一）死锁

出现死锁的原因：
1.存在两个或两个以上的共享资源
2.存在两个或者两个以上的线程使用这些共享资源
下面的代码会出现死锁；

package com.qfedu.a_thread;
class DeadLock extends Thread {
	public DeadLock(String name) {
		super(name);
	}
	
	@Override
	public void run() {
		if (Thread.currentThread().getName().equals("小胖")) {
			synchronized ("电池") {
				System.out.println("小胖有电池，想要遥控器");
				
				synchronized ("遥控器") {
					System.out.println("小胖拿到了遥控器，打开了投影仪");
				}
			}
		} else if (Thread.currentThread().getName().equals("逗比")) {
			synchronized ("遥控器") {
				System.out.println("逗比有遥控器，想要电池");
				
				synchronized ("电池") {
					System.out.println("逗比拿到了电池，打开了投影仪");
				}
			}
		}		
	}
}

public class Demo4 {
	public static void main(String[] args) {
		DeadLock d1 = new DeadLock("小胖");
		DeadLock d2 = new DeadLock("逗比");
		
		d1.start();
		d2.start();		
	}
}

输出结果：

小胖有电池，想要遥控器
逗比有遥控器，想要电池

（二）自定义线程

Java语言是一种单继承，多实现【遵从】面向对象的语言

自定义线程的方式：
- 方式1：
  1.自定义一个类，继承Thread类
  2.重写Thread里面的run方法，把线程的功能代码放入到run方法中
  3.创建自定义线程类对象
  4.开启线程，使用start方法
  - 弊端：
    因为Java是一个单继承的语言，一旦某一个类继承了Thread类，就无法再继承其他类，或者说一个类继承了其他类，也就没有办法继承Thread类
- 方式2: 强烈推荐
  【遵从】Runnable接口实现自定线程类
  1.自定义一个类，【遵从】Runnable接口
  2.实现Runnable接口中唯一要求的方法 Run方法，把线程的功能代码写入到run方法中
  3.创建Thread类对象，并且把【遵从】Runnable接口的自定义类对象，作为参数传入到Thread构造方法中
  4.调用Thread类对象的start方法，开启线程

package com.qfedu.a_thread;
import java.util.Arrays;
import java.util.Comparator;

class TestRunnable implements Runnable {

	//实现自定义线程类，遵从Runnable接口要求实现的Run方法，把线程代码写入到Runnable里面
	@Override
	public void run() {
		for (int i = 0 ; i < 10; i++) {
			System.out.println("当前线程为:" + Thread.currentThread());
		}
	}	
}

public class Demo5 {
	public static <T> void main(String[] args) {
		//创建Thread类对象，调用Thread构造方法中，需要传入Runnable接口实现类对象的方法~
		//方法一：
		Thread t1 = new Thread(new TestRunnable());//匿名对象

		//方法二：
		Thread t2 = new Thread(new Runnable() { //匿名内部类的匿名对象，不再需要定义上面的TestRunnable类 
			
			@Override
			public void run() {
				for (int i = 0; i < 10; i++) {
					System.out.println("匿名内部类的匿名对象，作为方法的参数，这里是作为线程对象的参数" + 
							Thread.currentThread());
				}
			}
		});
		
		t1.start();
		t2.start();
		
		/*
		target是在创建Thread类对象时候，传入的【遵从】Runnable接口的实现类，这个实现类中
		实现类【遵从】Runnable接口要求实现的run方法，在run方法中，就是定义的线程代码
		在Thread类中有一个成员变量
		//What will be run
		private Runnable target; 
		
		@Override
		public void run() {
			if (target != null) {
				target.run();
			}
		}
		*/
	}
}

三、守护线程(后台线程)

例如：
软件的Log日志文件，软件的自动更新，软件的自动下载

特征：
如果整个程序再运行过程中，只剩下一个守护线程，那么这个守护线程也就没有意义了，会自动停止

JVM的垃圾回收机制是守护线程。

这里当主线程停止，则下载也会自动停止；

package com.qfedu.a_thread;

public class Demo6 extends Thread {
	
	public Demo6(String name) {
		super(name);
	}
	
	//模拟后台下载更新的线程
	@Override
	public void run() {
		for (int i = 0; i <= 100; i++) {
			System.out.println("软件更新下载中………………" + i + "%");
			
			if (i == 100) {
				System.out.println("软件更新下载完成，是否安装~~");
			}
			
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) throws InterruptedException {
		Demo6 d = new Demo6("后台线程");
		
		//设置当前线程为守护线程或者是后台线程
		d.setDaemon(true);//true为守护线程
		
		//System.out.println(d.isDaemon());
		d.start();
		for (int i = 0; i <= 50; i++) {
			Thread.sleep(10);
			System.out.println("主线程:" + i);
		}
	}
}

四、线程通讯

线程通讯:
一个线程完成任务之后，通知另一个线程来完成该线程应该执行的任务

生产者和消费者问题:这里商品是两个线程直接的共享资源

wait(); 等待，如果一个线程执行了wait方法，那么这个线程就会进入临时阻塞状态，等待唤醒，这个唤醒必须其他线程调用notify() 方法唤醒;
notify(); 唤醒，唤醒线程池中进入【临时阻塞状态】的一个线程

注意事项：

wait()和notify()这两个方法都是Object类的方法
在消费者生产者模式下，锁对象只能是商品；

package com.qfedu.a_thread;

//两者之间的共享资源
class Product {
	String name; //商品的名字
	int price; //价格
	
	boolean flag = false; //产品是否生产成功，如果成功flag设置为true，消费者购买之后，设置为false
}

class Producer extends Thread {
	Product p;  //商品的类对象，是和消费者之间的共享资源
	
	public Producer(Product p) {
		this.p = p;
	}
	
	@Override
	public void run() {
		int count = 0;
		while (true) {
			synchronized (p) {
				try {
					sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				if (!p.flag) { //p.flag == false
					
					//商品不存在，生产过程
					if (count % 2 == 0) {
						p.name = "红辣椒擀面皮";
						p.price = 5;
					} else {
						p.name = "唐风阁肉夹馍";
						p.price = 10;
					}
					
					count++;
					System.out.println("生产者生产了:" + p.name + ":" + p.price);
					p.flag = true;
					//生产结束，唤醒消费者
					p.notify();
				} else {
					//商品存在，要求消费者来购买，生产者进入临时阻塞
					try {
						p.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} // try - catch
				}// if - else
			} // 同步代码块
		}// while (true)
	} //run()
}

class Customer extends Thread {
	Product p; //商品类对象，是和生产者之间的共享资源
	
	public Customer(Product p) {
		this.p = p;
	}
	
	@Override
	public void run() {
		while (true) {
			synchronized (p) {
				try {
					sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				if (p.flag) { //p.flag == true 
					//这里表示商品存在
					System.out.println("消费者购买了:" + p.name + ":" + p.price);
					
					p.flag = false; //表示消费者购买完毕，要求生产者生产
					//需要唤醒生产者
					p.notify(); //打开线程锁
				} else {
					try {
						//商品不存在，消费者进入临时阻塞
						p.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} // try - catch
				}// if - else 
			} //同步代码块
		} // while (true)
	} //run()
}

public class Demo7 {
	public static void main(String[] args) {
		Product product = new Product();
		
		Producer p = new Producer(product);
		Customer c = new Customer(product);
		
		p.start();
		c.start();
	}
}

[外链图片转存失败(img-c1SINa4C-1568986092783)($resource/%E5%8F%AF%E9%81%87%E4%B8%8D%E5%8F%AF%E6%B1%82%E7%9A%84%E9%94%99%E8%AF%AF.png)]

内容总结

以上是互联网集市为您收集整理的JavaDay24 多线程与多进程全部内容，希望文章能够帮你解决JavaDay24 多线程与多进程所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/951487.html

来源：【匿名】

【上一篇】java 导出 excel 最佳实践，大文件 excel 避免OOM(内存溢出) 框架-02-API 【下一篇】JAVA/JSP学习系列之五

更多 ►

【JavaDay24 多线程与多进程】教程文章相关的互联网学习教程文章

java多线程 21 ： ReentrantReadWriteLock ，synchronized和ReentrantLock的对比【代码】

读写锁ReentrantReadWriteLock概述大型网站中很重要的一块内容就是数据的读写，ReentrantLock虽然具有完全互斥排他的效果（即同一时间只有一个线程正在执行lock后面的任务），但是效率非常低。所以在JDK中提供了一种读写锁ReentrantReadWriteLock，使用它可以加快运行效率。读写锁表示两个锁，一个是读操作相关的锁，称为共享锁；另一个是写操作相关的锁，称为排他锁。我把这两个操作理解为三句话：1、读和读之间不互斥，因为读操作...

JAVA多线程（七）模式-Producer Consumer【代码】

Producer Consumer生产者创建数据，通过中介控制流量并安全传递给消费者。适用环境生产者生产数据的速度与消费者处理数据的速度不一致，中介者通过缓存和阻塞对消费者的数据压力进行调整。样例4生产者生产产品，放入市场，2消费者消费。产品package ProducerConsumer;public class Product {private String prdId=null;public Product(String prdId) {this.prdId=prdId;}public String getOrderId(){return this.prdId;} }市场pack...

Java多线程:线程同步与关键字synchronized

一、同步的特性1. 不必同步类中所有的方法, 类可以同时拥有同步和非同步方法.2. 如果线程拥有同步和非同步方法, 则非同步方法可以被多个线程自由访问而不受锁的限制. 参见实验1:http://blog.csdn.net/huang_xw/article/details/73185613. 如果两个线程要执行一个类中的同步方法, 并且两个线程使用相同的实例来调用方法, 那么一次只能有一个线程能够执行方法, 另一个需要等待, 直到锁被释放. 参见实验2:http://blog.csdn.net/huang_...

JAVA多线程之wait/notify【代码】【图】

本文主要学习JAVA多线程中的 wait()方法与 notify()/notifyAll()方法的用法。①wait() 与 notify/notifyAll 方法必须在同步代码块中使用②wait() 与 notify/notifyAll() 的执行过程③中断调用wait()方法进入等待队列的线程④notify 通知的顺序不能错⑤多线程中测试某个条件的变化用 if 还是用 while？ ①wait() 与 notify/notifyAll 方法必须在同步代码块中使用wait() 与 notify/notifyAll() 是Object类的方法，在执行两个方法...

【JAVA】HashMap的原理及多线程下死循环的原因【图】

再次翻到以前工作中遇到的一个问题，HashMap在多线程下会出现死循环的问题，以前只是知道会死循环，导致CPU100%把机器拖跨，今天来彻底看看首先来看下，HashMap的原理：HashMap是一个数组，对key使用hash算法计算出数组对应的下标i，然后把<key, value>插到table[i]，如果两个不同的key被算在同一个i，那就出现冲突，又叫碰撞，这样就会在table[i]上形成一个链表；总结下来HashMap是一个数组+链表组成的数据结构；我们知道，在往...

关于java多线程死锁的实验【代码】

先上完整的代码后续再依次修改代码块得到相应的结论 1//尝试写一个死锁感受一下 2publicclass DeadLock {3publicstaticvoid main(String[] args) {4 Object o1 = new Object();5 Object o2 = new Object();6//创建两个object对象7//创建两个Thread线程 8 Thread T1 = new Thread(new process1(o1,o2)); //两个线程T1、T2共享了相同的两个对象o1、o2 9 Thread T2 = new Thread(new process2(o1,o2)); 10 T1....

十七、Java从头开始-多线程编程：聊天室升级版

多线程编程：聊天室升级版?????? 还记得上一章的聊天室吗，不如说是单向发送器，我只能单方面的发送信息给客户端，不能接收消息，不能看到其他室友的发送的信息，我想要的是一个真正的聊天室，在发送信息的同时能看到我和其他室友发送的聊天记录，这里就不得不一边发送一边接收，意味着在用户与GUI交互的同时不能打断它，需要一个单独的执行空间来执行接收功能，就必须引进一个新的线程（Thread）。一、创建线程????? 创建一个线程...

java程序中的多线程(转)【代码】

为什么会排队等待？下面的这个简单的 Java 程序完成四项不相关的任务。这样的程序有单个控制线程，控制在这四个任务之间线性地移动。此外，因为所需的资源 ― 打印机、磁盘、数据库和显示屏 -- 由于硬件和软件的限制都有内在的潜伏时间，所以每项任务都包含明显的等待时间。因此，程序在访问数据库之前必须等待打印机完成打印文件的任务，等等。如果您正在等待程序的完成，则这是对计算资源和您的时间的一种拙劣使用。改进此程序的...

Java多线程间的通信问题扩展

到底什么是线程间的通信？线程间需要通过一些协调性的通信，实现共同完成同一件任务，简单说就是，你想做这件事，我也想做这件事，我们两个相互交流，共同做这件事，而共同任务的同步性的实现，就必须通过同步锁，每一个对象实例都有自己的一把锁，当一个线程想要对这个任务进行处理的时候，就必须获得这把锁。线程之间锁的释放与获取，是通过Object类中的wait()/notify()方法实现的。wait()方法是将当前拥有锁的线程至于等待状态让...

java多线程学习(四)——线程的交互

线程交互中用到的三个基本函数：void notify()；唤醒在此对象监视器上等待的单个线程。void notifyAll()；唤醒在此对象监视器上等待的所有线程。void wait();导致当前的线程等待，直到其他线程调用此对象的notify()或者notifyAll()方法。void wait(long timeout);wait()的重载版本，同样导致当前线程等待，直到其他线程调用此对象的notify()或者notifyAll()方法，或者等待超过指定的时间后不再等待。void wait(long timeout,int na...

JAVA程序设计(17)----- 制作文件拷贝软件进程输入流输出流 NIO 进度条底层拷贝多线程

使用NIO对文件进行底层拷贝（按照字节）多线程技术初级应用不阻塞程序运行package com.lovo.homework01;import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.channels.FileChannel;import javax.swing.JButton; impor...

Java多线程17：中断机制【代码】

概述之前讲解Thread类中方法的时候，interrupt()、interrupted()、isInterrupted()三个方法没有讲得很清楚，只是提了一下。现在把这三个方法同一放到这里来讲，因为这三个方法都涉及到多线程的一个知识点----中断机制。Java没有提供一种安全、直接的方法来停止某个线程，而是提供了中断机制。中断机制是一种协作机制，也就是说通过中断并不能直接终止另一个线程，而需要被中断的线程自己处理。有个例子举个蛮好，就像父母叮嘱出门在...

java实现多线程断点续传,上传下载【代码】【图】

采用apache 的 commons-net-ftp-ftpclient import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.PrintWriter; import java.io.RandomAccessFile;import org.apache.commons.net.PrintCommandListener; import org.apache.commons.net.ftp.FTP; import org.apache.commons.net.ftp.FTPClient; import org.apache.commons...

Java 中的多线程你只要看这一篇就够了【代码】【图】

引如果对什么是线程、什么是进程仍存有疑惑，请先Google之，因为这两个概念不在本文的范围之内。用多线程只有一个目的，那就是更好的利用cpu的资源，因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对，因为反应“多角色”的程序代码，最起码每个角色要给他一个线程吧，否则连实际场景都无法模拟，当然也没法说能用单线程来实现：比如最常见的“生产者，消费者模型”。很多人都对其中的一些概念不够明确，如同步...

Java中多线程的使用！！【代码】

简介： 1.要了解多线程，首先我们得先了解进程和线程。那么什么是进程？进程就是一个正在运行的程序分配内存让应用程序能够运行的叫做进程。那么什么又是线程呢？线程：在一个程序中，负责代码的执行，就是一个进程中的执行路劲的称为线程。然而，在一个进程中，同时又多个线程在执行不同的任务时，我们就称为多线程。 2.我们为什么要使用多线程呢？因为在一个进程中，有时候执行的任务，不仅仅只执行的是一个任务，有...

JAVA - 技术教程分类

Java 教程 Java 简介 Java 开发环境配置 Java 基础语法 Java 对象和类 Java 基本数据类型 Java 变量类型 Java 修饰符 Java 运算符 Java 循环结构 Java 条件语句 Java switch case Java Number & Math 类 Java Character 类 Java String 类 Java StringBuffer Java 数组 Java 日期时间 Java 方法 Java Stream、File、IO Java Scanner 类 Java 异常处理 Java 继承 Java Override/Overload Java 多态 Java 抽象类 Java 封装 Java 接口 Java 枚举 Java 包(package) Java 数据结构 Java 集合框架 Java ArrayList Java LinkedList Java HashSet Java HashMap Java Iterator Java Object Java 泛型 Java 序列化 Java 网络编程 Java 多线程编程 Java Applet 基础 Java 文档注释 Java 实例 Java 8 新特性 Java MySQL 连接 Java 9 新特性 Java 测验 java 全部

JAVA - 最热教程

Java在运行项目时候，点击右键的弹框，...nacos配置中心超时问题：java.net.Conn...Java的设计模式（7）— 生产者-消费者模...基于DOM4j和POI实现的XML文件转换为XLS...如何在Java中创建一些变量类型别名使用java8的Stream统计字符串数组中每一...idea插件篇之java内存分析工具(JProfil...cannot cast 'java.lang.Integer' to '...java – Bootstrap.properties中Spring...Java8利用stream流实现数字排序和中文排...

首页 / JAVA / JavaDay24 多线程与多进程

JavaDay24 多线程与多进程

内容导读

内容图文

JavaDay24 多线程与多进程

一、线程中的常用方法

二、线程的生命周期

三、线程的共享资源问题

（一）死锁

（二）自定义线程

三、守护线程(后台线程)

四、线程通讯

内容总结

内容备注

内容手机端

【JavaDay24 多线程与多进程】教程文章相关的互联网学习教程文章

java多线程 21 ： ReentrantReadWriteLock ，synchronized和ReentrantLock的对比【代码】

JAVA多线程（七）模式-Producer Consumer【代码】

Java多线程:线程同步与关键字synchronized

JAVA多线程之wait/notify【代码】【图】

【JAVA】HashMap的原理及多线程下死循环的原因【图】

关于java多线程死锁的实验【代码】

十七、Java从头开始-多线程编程：聊天室升级版

java程序中的多线程(转)【代码】

Java多线程间的通信问题扩展

java多线程学习(四)——线程的交互

JAVA程序设计(17)----- 制作文件拷贝软件进程输入流输出流 NIO 进度条底层拷贝多线程

Java多线程17：中断机制【代码】

java实现多线程断点续传,上传下载【代码】【图】

Java 中的多线程你只要看这一篇就够了【代码】【图】

Java中多线程的使用！！【代码】

JAVA - 相关标签

多线程 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程