多线程基础

最新推荐文章于 2022-04-11 11:10:13 发布
最新推荐文章于 2022-04-11 11:10:13 发布
阅读量369 收藏 2
点赞数 3
分类专栏： 一个女菜鸟的Java逆袭之路 文章标签： java 多线程 thread 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdncsd2/article/details/105906281
版权
  1. 第一种创建线程的方式：继承Thread并重写run方法来定义线程要执行的任务
public class ThreadDemo1 {

	public static void main(String[] args) {
			MyThread1 t1=new MyThread1();
			MyThread2 t2=new MyThread2();
			/*
			 * 启动线程要指定start方法，而不是直接调用run方法。run方法是线程要执行的任务
			 * 当线程的start方法被调用后，线程进入runnable状态，一旦获取CPU时间，run方法会自动被调用
			 */
			t1.start();
			t2.start();
	}

}
/*
 * 第一种创建线程的方式有两个不足
 * 1.由于Java是单继承，那么当继承了Thread后就无法再继承其他类
 * 2.由于继承Thread后重写run方法规定了线程执行的任务，这导致线程与任务有一个必然的耦合关系，不利于线程的重用。
 */
class MyThread1 extends Thread{
	public void run(){
		for(int i=0;i<1000;i++){
			System.out.println("你是谁呀？");
		}
	}
}
class MyThread2 extends Thread{
	public void run(){
		for(int i=0;i<1000;i++){
			System.out.println("我是查水表的");
		}
	}
}
  1. 第二种创建线程的方式：实现Runnable接口并重写run方法
public class ThreadDemo2 {

	public static void main(String[] args) {
		//单独定义任务
		Runnable r1=new MyRunnable1();
		Runnable r2=new MyRunnable2();
		
		Thread t1=new Thread(r1);
		Thread t2=new Thread(r2);
		
		t1.start();
		t2.start();
	}

}
class MyRunnable1 implements Runnable{
	public void run(){
		for(int i=0;i<1000;i++){
			System.out.println("你是谁呀？");
		}
	}
}
class MyRunnable2 implements Runnable{
	public void run(){
		for(int i=0;i<1000;i++){
			System.out.println("我是查水表的");
		}
	}
}
  1. 使用匿名内部类来完成方式一和方式二的线程创建
public class ThreadDemo3 {

	public static void main(String[] args) {
		//方式一
		Thread t1=new Thread(){
			public void run(){
				for(int i=0;i<1000;i++){
					System.out.println("你是谁呀");
				}
			}
		};
		t1.start();
		
		//方式二
		Runnable runn=new Runnable() {
			public void run() {
				for(int i=0;i<1000;i++){
					System.out.println("我是查水表的");
				}
				
			}
		};
		Thread t2=new Thread(runn);
		t2.start();

	}

}
  1. static Thread currentThread()
    获取运行当前方法的线程
public class ThreadDemo4 {

	public static void main(String[] args) {
		Thread main=Thread.currentThread();//运行main方法的线程
		System.out.println("运行main方法的线程是："+main);
		dosome();
		
		Thread t=new Thread(){
			public void run(){
				Thread t=Thread.currentThread();
				System.out.println("自定义线程："+t);
				dosome();
			}
		};
		t.start();

	}
	public static void dosome(){
		Thread t=Thread.currentThread();
		System.out.println("运行dosome方法的线程是:"+t);
	}

}
  1. 获取线程相关信息的方法
public class ThreadDemo5 {

	public static void main(String[] args) {
		// 获取运行main方法的线程
		Thread main=Thread.currentThread();
		long id=main.getId();
		System.out.println("id:"+id);//id:1   id值是系统分配的，不是我们能自己控制的
		
		String name=main.getName();
		System.out.println("name:"+name);//name:main
		
		int priority=main.getPriority();
		System.out.println("优先级："+priority);//优先级：5
		
		boolean isAlive=main.isAlive();
		System.out.println("是否存活："+isAlive);//是否存活：true
		
		boolean isDaemon=main.isDaemon();
		System.out.println("是否为守护线程："+isDaemon);//是否为守护线程：false
		
		boolean isInterrupted=main.isInterrupted();
		System.out.println("是否被中断："+isInterrupted);//是否被中断：false

	}

}
  1. 线程优先级：线程的时间片分配完全听线程调度的。线程只能被动的被分配时间，对于线程调度的工作不能干预。但是可以通过提高线程的优先级来达到尽可能干预的目的。 理论上，优先级越高的线程，获取CPU时间片的次数就越多。
public class ThreadDemo6 {

	public static void main(String[] args) {
		Thread min=new Thread(){
			public void run(){
				for(int i=0;i<10000;i++){
					System.out.println("min");
				}
			}
		};
		Thread norm=new Thread(){
			public void run(){
				for(int i=0;i<10000;i++){
					System.out.println("norm");
				}
			}
		};
		Thread max=new Thread(){
			public void run(){
				for(int i=0;i<10000;i++){
					System.out.println("max");
				}
			}
		};
		
		//设置优先级
		min.setPriority(Thread.MIN_PRIORITY);
		max.setPriority(Thread.MAX_PRIORITY);
		//norm不设置，默认为5
		
		min.start();
		norm.start();
		max.start();

	}

}
  1. static void sleep(long ms) 线程提供的静态方法sleep可以使运行该方法的线程进入阻塞状态指定毫秒。超时后线程会自动回到RUNNABLE状态。
public class ThreadDemo7 {

	public static void main(String[] args) {
		/*
		 * 完成电子表功能
		 * 每秒输出一次当前系统时间：17:36:55
		 */
		SimpleDateFormat sdf=new SimpleDateFormat("HH:mm:ss");
		while(true){
			System.out.println(sdf.format(new Date()));
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}

}
  1. 守护线程，又称为后台线程。当一个进程中的所有前台线程都结束时，进程就要结束，若还有后台线程运行，那么后台线程会被强制结束
public class ThreadDemo8 {

	public static void main(String[] args) {
		/*
		 * rose:前台线程
		 */
		Thread rose=new Thread(){
			public void run(){
				for(int i=0;i<10;i++){
					System.out.println("rose:let me go");
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						
					}
					
				}
				System.out.println("rose:aaaaa");
				System.out.println("音效：噗通");
			}
		};
		Thread jack=new Thread(){
			public void run(){
				while(true){
					System.out.println("jack：you jump,I jump！");
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		};
		//设置为后台线程--并且要在启动之前设置
		jack.setDaemon(true);
		rose.start();
		jack.start();

	}

}
  1. void join() join方法可以使调用该方法的线程进入阻塞状态，直到该方法所属线程完成工作才会解除调用该方法线程的阻塞状态。join方法一般用来完成多个线程之间的同步工作问题
public class ThreadDemo9 {
	//表示图片是否下载完毕
	public static boolean isFinish=false;
	
	public static void main(String[] args) {
		final Thread download=new Thread(){
			public void run(){
				System.out.println("down:开始下载图片...");
				for(int i=1;i<=100;i++){
					System.out.println("down:"+i+"%");
					try {
						Thread.sleep(50);
					} catch (InterruptedException e) {
					}
				}
				System.out.println("down:图片下载完毕");
				isFinish=true;
			}
		};
		Thread show=new Thread(){
			public void run(){
				System.out.println("show:开始显示图片...");
				/*
				 * 先等待download把图片下载完毕
				 */
				try {
					download.join();//调用download的join意思是：把show卡住，直到download把活干完
				} catch (InterruptedException e) {
					
				}
				
				if(!isFinish){
					throw new RuntimeException("图片没有下载完毕");
				}
				System.out.println("show:图片显示完毕");
			}
		};
		download.start();
		show.start();
	}

}
  1. 多线程并发访问同一资源时，就会形成“抢”的现象。由于线程切换时机不确定，可能导致执行代码顺序的混乱，严重时会导致系统瘫痪。
public class SyncDemo1 {

	public static void main(String[] args) {
		final Table table=new Table();
		Thread t1=new Thread(){
			public void run(){
				while(true){
					int bean=table.getBean();
					Thread.yield();
					System.out.println(getName()+":"+bean);
				}
			}
		};
		Thread t2=new Thread(){
			public void run(){
				while(true){
					int bean=table.getBean();
					Thread.yield();
					System.out.println(getName()+":"+bean);
				}
			}
		};
		t1.start();
		t2.start();

	}

}

class Table{
	//桌子上有20个豆子
	private int beans=20;
	
	 /**
	  * 当一个方法被synchronized修饰后，该方法为同步方法，即：多个线程不能同时进入方法内部执行
	  * 对于成员方法而言，synchronized会在一个线程调用该方法时将该方法所属对象加锁
	  * 其他线程在执行该方法时由于执行方法的线程没有释放锁，所以只能在方法外阻塞，直到持有方法锁
	  * 的线程将方法执行完毕。
	  * 所以，解决多线程并发执行安全问题的办法是将“抢”变为“排队”
	  * @return
	  */
	public synchronized int getBean(){
		if(beans==0){
			throw new RuntimeException("没有豆子了！");
		}
		Thread.yield();
		return beans--;
	}
}
  1. 同步块： 有效的缩小同步范围可以在保证并发安全的同时尽可能提高并发效率。
public class SyncDemo2 {

	public static void main(String[] args) {
		final Shop shop=new Shop();
		Thread t1=new Thread(){
			public void run(){
				shop.buy();
			}
		};
		Thread t2=new Thread(){
			public void run(){
				shop.buy();
			}
		};
		t1.start();
		t2.start();

	}

}

class Shop{
	public void buy(){
		//获取运行buy方法的线程
		Thread t=Thread.currentThread();
		try {
			System.out.println(t.getName()+":正在挑衣服");
			Thread.sleep(5000);
			/*
			 * 同步块可以要求多个线程对该块内的代码排队执行，但是前提条件是同步监视器对象
			 * 即（上锁的对象）要求多个线程看到的必须是同一个
			 * synchronized (同步监视器对象) {
					需要同步的代码
				}
			 * 所谓同步执行即：多个线程必须排队执行
			 * 所谓异步执行即：多个线程可以同时执行
			 */
			synchronized (t) {
				System.out.println(t.getName()+":正在试衣服");
				Thread.sleep(5000);
			}
			
			
			System.out.println(t.getName()+":结账离开");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
  1. 静态方法的同步 当一个静态方法被synchronized修饰后，那么该方法即为同步方法，由于静态方法从属类，全局就一份，所以同步的静态方法一定具有同步效果，与对象无关。
public class SyncDemo3 {

	public static void main(String[] args) {
		final Foo f1=new Foo();
		final Foo f2=new Foo();
		
		Thread t1=new Thread(){
			public void run(){
				f1.dosome();//与对象无关
			}
		};
		Thread t2=new Thread(){
			public void run(){
				f2.dosome();
			}
		};
		t1.start();
		t2.start();
	}

}


class Foo{
	public synchronized static void dosome(){
		try {
			Thread t=Thread.currentThread();
			System.out.println(t.getName()+":正在运行dosome方法");
			Thread.sleep(5000);
			System.out.println(t.getName()+":运行dosome方法完毕");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
  1. 互斥锁 synchronized也叫互斥锁，即：使用synchronized修饰多段代码，只要他们的同步监视器对象相同，那么这几段代码间就是互斥关系，即：多个线程不能同时执行这些代码。
public class SyncDemo4 {

	public static void main(String[] args) {
		final Boo boo=new Boo();
		Thread  t1=new Thread(){
			public void run(){
				boo.methodA();
			}
		};
		Thread  t2=new Thread(){
			public void run(){
				boo.methodB();
			}
		};
		t1.start();
		t2.start();

	}

}

class Boo{
	public synchronized void methodA(){
		try {
			Thread t=Thread.currentThread();
			System.out.println(t.getName()+":正在执行A方法");
			Thread.sleep(5000);
			System.out.println(t.getName()+":运行A方法完毕");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public synchronized void  methodB(){
		try {
			Thread t=Thread.currentThread();
			System.out.println(t.getName()+":正在执行B方法");
			Thread.sleep(5000);
			System.out.println(t.getName()+":运行B方法完毕");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
  1. 将集合或Map转换为线程安全的
public class SyncDemo5 {

	public static void main(String[] args) {
		/*
		 * ArrayList与LinkedList都不是线程安全的
		 */
		List<String> list=new ArrayList<String>();
		list.add("one");
		list.add("two");
		list.add("three");
		list.add("four");
		System.out.println(list);
		//将给定集合转换为线程安全的集合
		list=Collections.synchronizedList(list);
		System.out.println(list);
		
		
		/*
		 * HashSet不是线程安全的
		 */
		Set<String> set=new HashSet<String>();
		System.out.println(set);
		//将给定的Set集合转换为线程安全的
		set=Collections.synchronizedSet(set);
		System.out.println(set);
		
		/*
		 * HashMap也不是线程安全的
		 */
		Map<String,Integer> map=new HashMap<String,Integer>();
		map.put("语文", 98);
		map.put("数学", 95);
		map.put("英语", 89);
		System.out.println(map);
		map=Collections.synchronizedMap(map);
		System.out.println(map);
		
		/*
		 * API手册上有说明，就算是线程安全的集合那么其中对于元素的操作，如add，remove等方法
		 * 都不与迭代器遍历做互斥，需要自行维护互斥关系
		 */
		

	}

}
  1. 线程池 线程池主要有两个作用：1.重用线程 2.控制线程数量。当我们的应用需要创建大量线程或者发现线程会频繁的创建和销毁时就应当考虑使用线程池来维护线程。
public class ThreadPoolDemo {

	public static void main(String[] args) {
		ExecutorService threadPool=Executors.newFixedThreadPool(2);//创建线程池
		
		for(int i=0;i<5;i++){
			Runnable runn=new Runnable() {
				
				@Override
				public void run() {
					Thread t=Thread.currentThread();
					try {
						System.out.println(t+":正在运行任务");
						Thread.sleep(5000);
						System.out.println(t+"运行任务完毕");
					} catch (Exception e) {
						System.out.println("线程被中断");
					}
					
				}
			};
			threadPool.execute(runn);
			System.out.println("指派了一个任务交给线程池");	
		}
		threadPool.shutdownNow();
		System.out.println("停止线程池了");
	}

}
兔子eo
关注
专栏目录
java 线程同步互斥锁_Java04 线程同步问题解决——线程锁（同步锁、互斥锁）
weixin_42511121的博客
02-13 209
目录[TOC]写在最前：可能有误，请大家批评指正一、线程切换Java中，如果要实现在一个线程间的线程切换，需要在线程中使用Thread.yield()即可让出CPU时间。二、线程锁(也叫同步锁、互斥锁)线程锁可以在有效缩小同步范围的同时，尽可能的保证并发效率2.1 使用synchronized关键字对方法进行加锁对整个线程处理加锁(严重影响效率，不常用)2.1.1 语法public synchro...
线程模型
ChuckLin的博客
02-17 569
#Java线程及线程内存模型 ##1、说线程从线程的实现说起 线程在操作平台上有三种实现方式：使用内核线程实现方式、使用用户线程实现方式和混合方式 使用内核线程实现方式：使用内核线线程高级接口——轻量级进程也就是线程的一对一线程模型[轻量级线程(LWT-Light weight Thread)：内核线程(KLT-Kernal Thread)=1：1]，各种线程操作由内核通过操纵调度器进行系统调...
java继承的内存分析_Java学习笔记（15）-继承过程中，内存分析
weixin_39991305的博客
02-17 188
package day03;/** 继承时候对象的创建过程* 1 Java首先递归加载所有类搭配方法区* 2 分配父子类型的内存(实例变量)* 3 递归调用构造器*/public class Demo01 {public static void main(String[] args) {Goo g = new Goo();System.out.println(g.a+","+g.b+","+g.c...
学习java面向对象第三天：引用类型数组、继承、super、向上造型
qq_44966450的博客
01-19 1800
1.引用类型数组： 1)Bomb[] bs = new Bomb[3]; bs[0] = new Bomb(100,200); bs[1] = new Bomb(200,300); bs[2] = new Bomb(300,400); System.out.println(bs[0].width); //输出第1个炸弹的宽 bs[1].x = 250; //修改第2个炸弹的x为250 bs[2].move(); //第3个炸弹移动 for(int i=0;i<bs.l
循序渐进学Boo - 高级篇
weixin_30750335的博客
07-25 127
经过前面两篇文章的介绍，相信大家对Boo的一些基本特性有所了解，本文着重介绍Boo深层次的知识以及其在AOP中的实现。 在开始之前先给大家做些准备： 一、Boo Parser 目前Boo的编译器使用C#实现，用ANTLR进行解析。Compiler Steps Pipelines consist of a set of steps that the compiler passes the c...
多线程基础代码.rar
07-05
"多线程基础代码.rar"这个压缩包文件很可能是包含了一些关于多线程编程的基础示例代码，用于帮助初学者理解和实践多线程技术。 多线程允许一个应用程序同时执行多个不同的任务，每个任务被称为一个线程。在Java、C#...
多线程基础与基于多线程的简单聊天室
06-24
本压缩包“多线程基础与基于多线程的简单聊天室”提供了对多线程技术的实践理解和二次开发的基础。以下是关于这个主题的详细知识点： 1. **多线程的概念**：多线程是指在一个程序中同时执行多个不同的线程，每个...
多线程基础知识
03-01
通过学习和掌握这些多线程基础知识，开发者能够编写出更加高效、稳定的并发程序，提升软件系统的性能和用户体验。同时，对多线程深入理解也有助于应对面试中的技术考察，为职业生涯的晋升铺平道路。
初学JavaScript：js的组成、特点、作用、注释、变量和数据类型基本介绍
lalala_dxf的博客
04-11 2019
1、JavaScript的完整组成* ECMAScript，描述了该语言的语法和基本对象。 文档对象模型（DOM），描述处理网页内容的方法和接口。 浏览器对象模型（BOM），描述与浏览器进行交互的方法和接口。 ECMAScript【js标准】 由单行注释与块注释（ // 、/**/）、变量、操作符、流程控制语句、数组、对象、函数、正则表达式等构成的标准。目前基本所有的js解释器都可以兼容ECMAScript。 DOM文档对象模型【document object model】 简单来说就是使用JavaSc
归纳一下:C#线程同步的几种方法
weixin_33779515的博客
09-20 356
　　我们在编程的时候，有时会使用多线程来解决问题，比如你的程序需要在后台处理一大堆数据，但还要使用户界面处于可操作状态；或者你的程序需要访问一些外部资源如数据库或网络文件等。这些情况你都可以创建一个子线程去处理，然而，多线程不可避免地会带来一个问题，就是线程同步的问题。如果这个问题处理不好，我们就会得到一些非预期的结果。 　　在网上也看过一些关于线程同步的文章，其实线程同步有好几种方法，下面我就...
abstract
csdncsd2的博客
03-28 1160
抽象方法 1.由abstract修饰 2.只有方法的定义，没有方法的实现（大括号都没有） 抽象类 1. 由abstract修饰 2.包含抽象方法的类必须是抽象类，不包含抽象方法的类也可以声明为抽象类 3.抽象类不能被实例化 4.抽象类是需要被继承的，子类： 4.1 重写所有抽象方法–常用 4.2 也声明为抽象类–不常用 5.抽象类的意义： 5.1 包含公共的属性和行为，被子类所共享–代码重用 5...
java查询表
csdncsd2的博客
04-22 764
1. java.util.Map： Map看起来像是一个多行两列的表格。以key-value对的形式存放元素。在Map中key不允许重复（重复是依靠key的equals判断）。 常用的实现类是：HashMap。 public static void main(String[] args) { Map<String,Integer> map =new HashMap<Strin...
java里的进制
csdncsd2的博客
04-17 433
二进制：计算机只能处理二进制数据，利用编程语言提供的算法支持了十进制；计算机的内部（Java）只有二进制数据，在显示的时候编程语言提供API将二进制转换为十进制显示出来；计算机表面上支持了十进制，但其实不支持。 Java中有两个方法： Integer.toString() 将二进制数据转换为十进制输出 Integer.parseInt() 将十进制字符串转换为二进制数据 int n=45; ...
Java里的变量----程序中用于存储数据的容器
csdncsd2的博客
03-19 412
变量的声明 int a;//声明一个整型变量，名为a int b,c,d;//声明b,c,d三个整型变量 变量的命名 驼峰命名法（五个规定） 类名/接口名：如果由多个单词组成，那么每一个单词的首字母大写。HelloWorld 变量名/方法名：如果由多个单词组成，那么第一个单词的首字母小写，其余单词的首字母大写。playGame、main。 包名：如果是由多个单词组成，那么每一个单词之间...
TCP通信--聊天室
csdncsd2的博客
05-04 323
聊天室客户端 public class Client { /* * 套接字--可以理解为电话 * java.net.Socket * 封装了TCP协议，使用它就可以基于TCP协议进行网络通讯 * Socket是运行在客户端的 */ private Socket socket; /** * 构造方法，用来初始化客户端 * 实例化Socket的时候需要传入两个参数...
static final常量
csdncsd2的博客
03-28 316
static final常量 1.必须声明同时初始化 2.不能改变，通过类名点来访问 3.建议：常量名所有字母都大写 4.在编译时会自动替换为具体的值，效率更高 public class StaticFinalDemo { public static void main(String[] args) { System.out.println(Aoo.PI);//通过类名点来访问 //A...
C#多线程基础解析与应用
"C#多线程基础教程" 在C#编程中，多线程是一个重要的概念，它允许程序同时执行多个任务，从而充分利用系统资源，提高程序效率。本教程将介绍C#中如何创建和管理多线程。 一、线程的基本概念 线程是操作系统分配...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值