java基础---多线程1

最新推荐文章于 2022-11-25 15:39:34 发布
最新推荐文章于 2022-11-25 15:39:34 发布
阅读量250 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tdoa1024/article/details/86624693
版权

进程：正在运行的程序（直译）分配程序的内存空间
线程：就是进程中的一个负责程序执行的控制单元（执行路径）
一个进程中可以有多执行路径，称之为多线程
一个进程中至少有一个线程

开启多个线程是为了同时运行多个代码。
每一个线程都有自己的运行内容，这个内容可以称之为线程要执行的任务。

多线程的好处：解决了部分同时运行的问题
多线程的弊端：线程太多转换效率会低
其实应用程序的执行都是CPU在做着快速的切换完成的。这个切换是随机的。

JVM启动时就启动了多个线程，至少有两个线程可以解析出来。
1.执行main函数的线程
    该线程的任务代码都定义在main函数中
2.负责垃圾回收的线程

如何创建一个线程：
方式一：继承Thread类

步骤：

  1. 定义一个类extend Thread类
  2. 覆盖Thread类中的run方法
  3. 直接创建Thread的子类的对象创建线程
  4. 调用start方法开启线程，让虚拟机调用该线程的run方法

start开启线程调用run方法

	class Demo extends Thread
	{
		String name;
		Demo(String name)
		{
			this.name=name;
		}
		public void show()
		{
			for(int x=1;x<10;x++)
			{
				for(int y=-9999999;y<99999999;y++){}
				System.out.println("name is "+name+Thread.currentThread().getName());
			}
		}
		public void run()
		{
			show();
		}
	}
	class ThreadDemo  
	{
		public static void main(String[] args) 
		{
			Demo a=new Demo("周杰伦");
			Demo b=new Demo("陈奕迅");
			a.start();
			b.start();
		}
	}

 

创建线程的目的是为了开启一条执行路径，取运行指定的代码和其他代码实现同时运行。

而运行的指定代码就是这个执行路径的任务。

JVM创建的主线程的任务都定义在了主函数中，而自定义的线程的任务在哪？
    Thread类用于描述线程，线程是需要任务的。所以Thread的类也对任务有描述。
    这个任务描述就是通过Thread类中的run方法来体现。也就是说，run方法是封装自定义线程运行任务的函数。
    run方法定义的就是线程中要运行的任务代码。
    开启线程是为了运行指定的代码，所以需要继承Thread类并复写run方法。
    将运行的代码定义在run方法中即可。
    
可以通过Thread的getName()获取线程名称。THread-编号(从0开始)
通过Thread的getName()获取当前运行线程的名字
通过Thread的currentThread返回当前正在执行线程的引用。

                                                      多线程的状态

创建线程的第二种方式：实现Runnable

步骤：

  1. 定义实现Runnable接口；
  2. 覆盖接口中的run方法，将线程的任务代码封装到run方法中；
  3. 通过Thread类创建线程对象，并将Rnnable接口的子类对象作为Thread类的构造函数的参数进行传递。      why？因为线程的任务都封装在Runnable接口的子类对象的run方法中。所以要在线程对象创建时就必须明确要运行的任务。
  4. 调用线程对象的start方法开启线程。
	class Demo2 implements Runnable
	{
		String name;
		Demo(String name)
		{
			this.name=name;
		}
		public void show()
		{
			for(int x=1;x<10;x++)
			{
				for(int y=-9999999;y<99999999;y++){}
				System.out.println("name is "+name+Thread.currentThread().getName());
			}
		}
		public void run()
		{
			show();
		}
	}
	class ThreadDemo  
	{
		public static void main(String[] args) 
		{
			Demo d=new Demo("周杰伦");
			Thread t1=new Thread(d);
			Thread t2=new Thread(d);
			t1.start();
			t2.start();
		}
	}
	
	//Thread类的内部实现
	class Thread{
		private Runnable r;
		Thread(){
		//空参数
		}
		Thread(Runnable r){
			this.r=r;
		}
		public void run(){
			if(r!=null)
			r.run();
		}
		public void start(){
			run();
		}
		...
	}

 实现Runnable接口的好处：

  1. 将线程的任务从线程的子类中分离出来，进行单独的封装。按照面向对象的思想将任务封装成对象。
  2. 避免了java单独继承的局限性。所以，创建线程的第二种方法比较常用。

买票问题第一种实现：出现了四个ticket对象，导致变成400张票

解决方式之一是静态num。 

class Ticket extends Thread
{
	private static int num=100;
	public void run(){
		while(true){
		if(num>0)
			System.out.println(Thread.currentThread().getName()+"...num="+name);
		}	
	}
}

class TicketTestDemo 
{
	public static void main(String[] args) 
	{
		Ticket t1=new Ticket();
		Ticket t2=new Ticket();
		Ticket t3=new Ticket();
		Ticket t4=new Ticket();
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

 

解决方式之二是使用Runnable接口。

class Ticket implements Runnable
{
	private int num=100;
	public void run(){
		while(true){//隐患，线程安全问题
		if(num>0)
			System.out.println(Thread.currentThread().getName()+"...num="+name--);
		}	
	}
}

class TicketTestDemo 
{
	public static void main(String[] args) 
	{
		Ticket t=new Ticket();
		Thread t1=new Thread(t);
		Thread t2=new Thread(t);
		Thread t3=new Thread(t);
		Thread t4=new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

线程安全问题的产生：
1.多个线程在操作共享的数据
2.操作共享数据的线程代码有条。
当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算。就会导致线程安全问题的产生。

解决思路：
就是将多条操作共享数据的线程代码封装起来，当有线程代码在执行这些代码的时候，其他线程是不可以参与运算的。
必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。
在java中，用同步代码块就可以解决这个问题。

同步代码块的格式：
synchronized(对象)
{
    需要被同步的代码块;
}

同步的好处：解决了线程安全问题
同步的弊端：相对降低了效率，因为同步外的线程都会判断同步锁。
同步的前提：同步中必须有多个线程并使用同一个锁。

class Ticket implements Runnable
{
	Object obj=new Object();
	private int num=100;
	public void run()
	{
		while(true){
		synchronized(obj)
		{
			if(num>0)
				System.out.println(Thread.currentThread().getName()+"...num="+name--);
			}	
		}
	}
}

class TicketTestDemo 
{
	public static void main(String[] args) 
	{
		Ticket t=new Ticket();
		Thread t1=new Thread(t);
		Thread t2=new Thread(t);
		Thread t3=new Thread(t);
		Thread t4=new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

同步的第二种表现形式：同步函数

银行存款：2个人到银行分别分三次存300块钱

class Bank
{
//	private Object obj=new Object();
	private int sum;
	public synchronized void add(int num)//同步的第二种表现形式，同步代码块
	{
//		synchronized(obj){
		sum=sum+num;
		System.out.println(Thread.currentThread().getName()+"sum="+sum)
//		}
	}
}

class Consumer implements Runnable
{
	Bank b=new Bank();
	public void run()
	{
		for(int i=0;i<3;i++){
			b.add(100);
		}	
	}
}

class BankDemo 
{
	public static void main(String[] args) 
	{
		Consumer c=new Consumer();
		Thread t1=new Thread(c);
		Thread t2=new Thread(c);
		t1.start();
		t2.start();
	}
}

同步函数使用的锁是this：
同步函数和同步代码块的区别：同步函数的锁是固定的this，同步代码块的锁是任意的对象。
建议使用同步代码块。

class Ticket implements Runnable
{
//	Object obj=new Object();
	private int num=100;
	private boolean flag=true;
	public void run()
	{
		if(flag)
		{
			while(true){
			synchronized(this)
			{
				if(num>0)
				{
					try{Thread.sleep(10);}catch(InterruptedException e){}
					System.out.println(Thread.currentThread().getName()+"...num="+name--);
				}	
			}
		}else{
			while(true)
			{
				this.show();
			}
		}
	}
	public synchronized void show(){
			if(num>0){
				try{Thread.sleep(10);}catch(InterruptedException e){}
				System.out.println(Thread.currentThread().getName()+"...num="+name--);	
			}
	}

}

class TicketTestDemo 
{
	public static void main(String[] args) 
	{
		Ticket t=new Ticket();
		Thread t1=new Thread(t);
		Thread t2=new Thread(t);
		t1.start();
		t2.start();
	}
}

静态的同步函数使用的锁是 该函数所属的字节码文件对象
可以使用getClass方法获取，也可使用当前的 类名.class表示

死锁：同步嵌套

class Ticket implements Runnable
{
	private  int num = 100;
	Object obj = new Object();
	boolean flag = true;
	public void run()
	{


		if(flag)
			while(true)
			{
				synchronized(obj)
				{
					show();
				}
			}
		else
			while(true)
				this.show();
	}

	public synchronized void show()
	{

		synchronized(obj)
		{
			if(num>0)
			{
				try{Thread.sleep(10);}catch (InterruptedException e){}
				
				System.out.println(Thread.currentThread().getName()+".....sale...."+num--);
			}
		}
	}
}


class DeadLockDemo 
{
	public static void main(String[] args) 
	{
		Ticket t = new Ticket();
//		System.out.println("t:"+t);

		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);

		t1.start();
		try{Thread.sleep(10);}catch(InterruptedException e){}
		t.flag = false;
		t2.start();
	}
}

死锁的简化版：同步嵌

public class Solution21 {

	public static void main(String[] args) {
		new Thread(new LockDemo(true)).start();
		new Thread(new LockDemo(false)).start();
	}
}

class MyLock {

	public static final Object lock_a = new Object();
	public static final Object lock_b = new Object();
}

class LockDemo implements Runnable {

	private boolean flag;

	public LockDemo(boolean flag) {
		this.flag = flag;
	}

	public void run() {

		if (flag) {
			while (true)
				synchronized (MyLock.lock_a) {
					System.out.println(Thread.currentThread().getName() + "lock_a   if....");
					synchronized (MyLock.lock_b) {
						System.out.println(Thread.currentThread().getName() + "lock_b   if....");
					}
				}
		} else {
			while (true) 
				synchronized (MyLock.lock_b) {
					System.out.println(Thread.currentThread().getName() + "lock_a   else....");
					synchronized (MyLock.lock_a) {
						System.out.println(Thread.currentThread().getName() + "lock_b   else....");
					}
				}
		}
	}
}

 

Wnlife
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JAVA-多线程 所有文件
01-09
JAVA-多线程 所有文件
Java基础---多线程宝典
codeLife
11-30 1万+
多线程 文章目录多线程核心概念`Process`与`Thread`线程三种创建方式继承`Thread`类使用多线程实现下载网络图片实现`Runnable`接口多线程同时操作同一个对象模拟龟兔赛跑(线程执行速度)实现`Callable`接口静态代理`Lanmda`表达式简介作用：函数式接口`Functional Interface`定义示例：Lambda表达式简化：总结线程状态创建总结就绪线程礼让运行阻塞线程休眠`Sleep``Join`合并线程死亡线程状态观测线程优先级守护线（daemon）程线程同步死锁产
Java多线程--AQS的原理
IT利刃出鞘的博客
11-04 3922
本文介绍Java中的AQS的原理。 Java的AQS是JDK自带的锁机制，是JUC（java.util.concurrent）的基础，很多并发类都是基于它实现的，例如：ReentrantLock、CountDownLatch、Semaphore、ReadWriteLock，CyclicBarrier。
Java基础---多线程
我是太阳
01-28 2万+
1、程序、进程、线程 2、线程的创建和使用 3、线程的生命周期 4、线程的同步 例题：模拟火车站售票程序，开启三个售票窗口 public class Ticket implements Runnable { private int tick = 100; @Override public void run() { ...
Java - 多线程
热门推荐
了解➔熟悉➔掌握➔精通
03-23 3万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 引 如果对什么是线程、什么是进程仍存有疑惑，请先Google之，因为这两个概念不在本文讨论的范围之内。 用多线程只有一个目的，那就是更好的利用CPU的资源，因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对，因为反应”多角色”的程序...
Java多线程--基础知识
IT利刃出鞘的博客
11-04 2496
本文介绍Java多线程的基础知识。包括：多线程同步的实现方式，死锁产生的条件，如何避免死锁。 多线程同步的方案 方式 优点 缺点 使用场景 synchronized 使用简单；CPU占用低 响应缓慢（并发性能差）；不灵活。 并发量低；大的代码块 同步方法/代码块 并发集合（List,Map） 例：ConcurrentHashMap等 并发性能高 ...
Java高级特性 - 多线程基础（1）使用线程
weixin_62440328的博客
11-25 915
【代码】Java高级特性 - 多线程基础（1）使用线程。
Java基础进阶多线程-死锁
qq_46096136的博客
09-11 6081
两个线程共享两个对象o1,o2线程1先把o1锁住，再把o2锁住线程2先把o2锁住，再把o1锁住此时程序会静止不动。
6-6 jmu-Java-07多线程-同步访问 (10 分)
m0_54524462的博客
12-02 3052
6-6 jmu-Java-07多线程-同步访问 (10 分) 现已有Account类，拥有 属性: private int balance 方法: 相应的getter方法。 要求为该类编写： void deposit(int money) //存钱，在余额的基础上加上money void withdraw(int money) //取钱，在余额的基础上减去money 注意： 取钱时如果balance<0的时候，会抛出异常。在多线程情况下，如只有一个存钱的线程，但是有多个取钱的线程，很可能会抛出异常。
Java多线程--1--stop方法
qq_39611310的博客
06-21 2126
Java 多线程基础 – stop()方法 stop方法：强制停止一个正在运行的线程，无论此时线程是何种状态。 stop方法在停止线程时需要自行指定线程退出逻辑，否则线程会立即退出，不做任何清理操作，非常不安全，会造成数据不一致问题。 此处引用API的介绍 该方法具有固有的不安全性。用 Thread.stop 来终止线程将释放它已经锁定的所有监视器（作为沿堆栈向上传播的未检查 ThreadDeath 异常的一个自然后果）。 如果以前受这些监视器保护的任何对象都处于一种不一致的状态，则损坏的对象将对其他线程
Java基础-Runnable启动线程的使用
二丫的博客
09-26 3575
Runnable启动线程的使用 实现线程的第二种方式： Runnable接口 Runnable 接口的实现类的线程 通过Thread类启动 需要把实现类对象传入Thread类的构造方法中 然后通过Thread的start方法启动该Runnable实现类的线程。 Runnable实现类线程 只需要创建一个对象 然后传入多个Thread类构造方法中，通过多个Thread对象去启动多个线程。 Runnable接口的优点： 可以避免由于Java单继承带来的局限性（不占继承名额） 适合多个相同程序的代码去处
Java基础[06-多线程].ppt
12-09
Java线程具有五中基本状态 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread(); 就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。...
Java多线程基础-优秀程序员
04-10
线程开发05_线程命名06_线程休眠07_线程优先级08_线程礼貌09_关键资源问题关键../等待...源码详情01_串行与并发02_进程与线程"03线程的生命04.线程的开辟05_线程的命名06_线程的休眠07_线程的优先08_线程的礼让09_...
大学课程讲义-Java基础-多线程.pptx
最新发布
08-14
大学课程讲义_Java基础_多线程.pptx
Java-学习多线程总结上
12-22
每一个正在执行的程序都是一个进程，资源只有一块，所以在同一时间段会有多个程序同时执行，但是在一个时间点上，只能由一个程序执行，多线程是在一个进程的基础之上的进一步划分，因为进程的启动所消耗的时间是非常...
Cookie && Session && 获取上次登录的时间 && 显示商品浏览记录&&购物车
TDOA1024的博客
12-04 933
Cookie: cookie 是 servlet 发送到 Web 浏览器的少量信息，这些信息由浏览器保存，然后发送回服务器。cookie 的值可以唯一地标识客户端，因此 cookie 常用于会话管理。 一个 cookie 拥有一个名称、一个值和一些可选属性，比如注释、路径和域限定符、最大生存时间和版本号。一些 Web 浏览器在处理可选属性方面存在 bug，因此有节制地使用这些属性可提高 ser...
JAVA基础---NIO
TDOA1024的博客
05-17 669
1. java NIO简介： Java NIO（New IO）是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。 2. Java NIO 与IO 的主要区别 IO NIO 面向流(St...
JSE基础总结1---小细节
TDOA1024的博客
01-04 573
dos常用命令行：     dir:列出当前目录的文件夹     md:创建目录     rd:删除目录     cd:进入指定目录     cd..:退回上一级目录     cd\:退回根目录     del：删除文件     exit:退出dos命令行     配置虚拟路径：将要配置的路径添加到原先路径中 set path=要配置的目录;%path% classpath配置： set cl...
Http协议&Servlet
TDOA1024的博客
11-23 495
Http协议： 什么是协议？ 双方在交互，通讯的时候，遵守的一种规范 http协议： 针对网络上的客户端 与 服务端执行http请求的时候，遵守的一种规范。其实就是规定了客户端在访问服务端的时候，要带上什么东西，服务端返回数据的时候，也要带上什么东西。 版本： 1.0      请求数据，服务器返回后，将会断开连接 2.0     请求数据，服务器返回后，连接还会保持着，除非服务器|客户端关掉。...
java高级特性 - 多线程基础(1)使用线程
06-28
Java高级特性中的多线程基础是指使用线程来实现并发执行的程序。线程是程序执行的最小单位，可以同时执行多个线程，提高程序的执行效率和响应速度。在Java中，使用Thread类和Runnable接口来创建和启动线程。线程的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值