JAVA多线程基础

最新推荐文章于 2022-03-28 16:08:22 发布
最新推荐文章于 2022-03-28 16:08:22 发布
阅读量160 收藏
点赞数
分类专栏： JAVA进阶 文章标签： java 多线程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34488912/article/details/106349468
版权

0.相关概念

并行：多个事件同一时间段内发生。
并发：多个事件同一时间发生。
进程：是程序运行的基本单位，一个运行的程序可以同时运行多个进程。
线程：是进程的一个执行单元，一个进程可以有多个线程。

1.线程创建的三种方式

1.1继承Thread类

	package thread;

public  class Mythread extends Thread {
    @Override
    public void run() {
        System.out.println("继承Thread");
    }

    public static void main(String[] args) {
            Mythread mythread = new Mythread();
            mythread.start();
    }
}

1.2实现runnable接口（最常用，最重要）
1.2.1方法一：通常方法

	package thread;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("实现Runnable");
    }

    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread t = new Thread(runnable);
        t.start();

    }
}

1.2.2方法二：匿名内部类

package thread;

public class MyRunnable  {
    public static void main(String[] args) {
        //1
        /*Runnable runnable = new Runnable(){
            @Override
            public void run() {
                System.out.println("匿名内部类实现Runnable");
            }
        };
        new Thread(runnable).start();//静态代理*/
        //2
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类简化");
            }
        }).start();
    }
}
    }
}

1.2.3方法三：Lambda表达式

package thread;

public class MyRunnableLambda {
    public static void main(String[] args) {
        new Thread(()-> System.out.println("Lambda表达式实现Runnable接口")).start();
    }
}

1.2.3
1.3实现Callable接口（不常用，不建议）
多了返回值，可以抛出异常

	class MyCallable implements Callable<Integer>{
	    @Override
	    public Integer call() throws Exception {
	        System.out.println("Callable这个线程被创建了！！！");
	        return;
	    }
	}

2.线程方法

2.1线程停止
2.1.1建议线程正常停止–>利用次数，不建议死循环
2.1.2建议使用标志位–>设置一个标志位
2.1.3不要使用stop或者destroy等过时或者jdk官网不建议使用的方法

   
public class Teststop implements Runnable {
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        System.out.println("线程在运行" + (i++));
    }
    public  void stop() {
        this.flag = false;
    }
    public static void main(String[] args) {
        Teststop teststop = new Teststop();
        new Thread(teststop).run();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main" + i);
            if (i == 900) {
                teststop.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

2.2线程休眠
在程序中允许一个线程进行暂时的休眠，直接使用 Thread.sleep() 即可实现休眠。

public class Testsleep {
    public static void main(String[] args) throws InterruptedException {
        Date starttime = new Date(System.currentTimeMillis());
        while (true){
            Thread.sleep(1000);//休眠一秒
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(starttime));
            starttime = new Date(System.currentTimeMillis());//更新当前时间
        }
    }
}

2.3线程礼让
Thread.yield(); 让当前线程让出时间片，再竞争一次，CPU重新调度，礼让不一定成功。

	// 礼让线程，让出当前执行线程，但不阻塞，运行状态改成就绪状态
	// 礼让不一定成功，要看CPU的心情
	public class TestYield {
	    public static void main(String[] args) {
	        Myyield myyield = new Myyield();	
	        new Thread(myyield,"a").start();
	    }
	}
	class Myyield implements Runnable{
	    @Override
	    public void run() {
  System.out.println(Thread.currentThread().getName()+"线程开始");
	        Thread.yield();
System.out.println(Thread.currentThread().getName()+"线程结束");
	    }
	}

2.4线程强制执行
thread.join(); 在一个线程里面强行插入另外一个线程，直到插入的线程执行结束才回来执行原线程。
2.5线程优先级
static int ---------MAX_PRIORITY
线程可以拥有的最大优先级。
static int ---------MIN_PRIORITY
线程可以拥有的最小优先级。
static int -------- NORM_PRIORITY
被分配给线程的默认优先级。
void setPriority(int newPriority)
更改此线程的优先级。
int getPriority()

class MyThread implements Runnable{ // 实现Runnable接口
    public void run(){  // 覆写run()方法
        for(int i=0;i<5;i++){
            try{
                Thread.sleep(500) ; // 线程休眠
            }catch(InterruptedException e){
            }
            System.out.println(Thread.currentThread().getName()
                    + "运行，i = " + i) ;  // 取得当前线程的名字
        }
    }
};
public class ThreadPriorityDemo{
    public static void main(String args[]){
        Thread t1 = new Thread(new MyThread(),"线程A") ;  // 实例化线程对象
        Thread t2 = new Thread(new MyThread(),"线程B") ;  // 实例化线程对象
        Thread t3 = new Thread(new MyThread(),"线程C") ;  // 实例化线程对象
        t1.setPriority(Thread.MIN_PRIORITY) ;   // 优先级最低
        t2.setPriority(Thread.MAX_PRIORITY) ;   // 优先级最高
        t3.setPriority(Thread.NORM_PRIORITY) ;  // 优先级最中等
        t1.start() ;    // 启动线程
        t2.start() ;    // 启动线程
        t3.start() ;    // 启动线程
    }
};

返回此线程的优先级。
2.6守护线程

   God god = new God();
   You you = new You();
   Thread thread = new Thread(god);
   thread.setDaemon(true); // 默认的是false，表示的是用户线程，正常的都是用户线程
   thread.start(); // 上帝守护线程启动
   new Thread(you).start();

3.线程状态

在这里插入图片描述

4.线程安全

4.1线程同步
线程同步：多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。
同步方法：使用synchronized修饰的方法，保证当前线程在执行该方法的时候，其它线程只能在方法外排队。
同步代码块：synchronized关键字用于方法中的某个区块，表示只对这个区块的资源实行互斥访问。
格式:

 synchronized (同步锁){
            需要同步的代码块
        }

在这里插入图片描述
三个不安全的例子：
1.不安全的买票

package demo3;
//不安全的买票
public class UnsafeBuyTiket {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BuyTicket station = new BuyTicket();
		new Thread(station,"苦逼的我").start();
		new Thread(station,"牛逼的大家").start();
		new Thread(station,"可恶的黄牛").start();
	}

}
class BuyTicket implements Runnable{
	//票
	private int ticketNums = 10;
	boolean flag = true;//外部停止方式
	@Override
	public void run() {
		//买票
		while(flag)
		{
			try{
				buy();
			}catch(InterruptedException e)
			{
				e.printStackTrace();
			}
		}
	}
	private void buy() throws InterruptedException{
		//判断是否有票
		if(ticketNums<=0)
		{
			return;
		}
		
		//模拟延时
		Thread.sleep(100);
		//买票
		System.out.println(Thread.currentThread().getName()+"拿到了"+ticketNums--+"票");
	}
}

运行结果（出现-1张票）：
在这里插入图片描述
同步方法及同步块(synchronized)(把不安全的改成安全的)

package demo3;
//不安全的买票
public class UnsafeBuyTiket {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BuyTicket station = new BuyTicket();
		new Thread(station,"苦逼的我").start();
		new Thread(station,"牛逼的大家").start();
		new Thread(station,"可恶的黄牛").start();
	}

}
class BuyTicket implements Runnable{
	//票
	private int ticketNums = 10;
	boolean flag = true;//外部停止方式
	@Override
	public void run() {
		//买票
		while(flag)
		{
			try{
				buy();
			}catch(InterruptedException e)
			{
				e.printStackTrace();
			}
		}
	}
	//同步方法，锁的是this
	private synchronized void buy() throws InterruptedException{
		//判断是否有票
		if(ticketNums<=0)
		{
			return;
		}
		
		//模拟延时
		Thread.sleep(100);
		//买票
		System.out.println(Thread.currentThread().getName()+"拿到了"+ticketNums--+"票");
	}
}

运行结果（-1没了）：
在这里插入图片描述
2.不安全的取钱

package demo3;
//不安全的取钱
//两个人去银行取钱，账户
public class UnsafeBank {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Account a = new Account(100,"结婚基金");		
		Drawing you = new Drawing(a,50,"你");
		Drawing girl = new Drawing(a,100,"girl");		
		you.start();
		girl.start();		
	}
}
//账户
class Account{
	int money;//余额
	String name;//卡名
	public Account(int money,String name)
	{
		this.money = money;
		this.name = name;
	}
}
//银行：模拟取款
class Drawing extends Thread{
	Account account;//账户
	int drawingMoney;//取了多少钱
	int nowMoney;//现在手里有多少钱
	public Drawing(Account account,int drawingMoney,String name) {
		super(name);
		this.account = account;
		this.drawingMoney = drawingMoney;
	}
	//取钱
	@Override
	public void run() {
		//判断有没有钱
		if(account.money-drawingMoney<0)
		{			System.out.println(Thread.currentThread().getName()+"钱不够");
			return;
		}
		//sleep可以放大问题的发生性
		try {
			Thread.sleep(1000);
		}catch(Exception e)
		{
			e.printStackTrace();
		}
		//卡内余额=余额-你取的钱
		account.money = account.money-drawingMoney;
		//你手里的钱
		nowMoney = nowMoney + drawingMoney;
		System.out.println(account.name+"余额为"+account.money);		
		//这两个操作等价		//System.out.println(this.getName()+Thread.currentThread().getName());
		System.out.println(this.getName()+"手里的钱"+nowMoney);
	}
}

运行结果（存款为负数）：
在这里插入图片描述

package demo3;
//不安全的取钱
//两个人去银行取钱，账户
public class UnsafeBank {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Account a = new Account(100,"结婚基金");
		
		Drawing you = new Drawing(a,50,"你");
		Drawing girl = new Drawing(a,100,"girl");
		
		you.start();
		girl.start();
		
	}

}
//账户
class Account{
	int money;//余额
	String name;//卡名
	public Account(int money,String name)
	{
		this.money = money;
		this.name = name;
	}
}
//银行：模拟取款
class Drawing extends Thread{
	Account account;//账户
	int drawingMoney;//取了多少钱
	int nowMoney;//现在手里有多少钱
	public Drawing(Account account,int drawingMoney,String name) {
		super(name);
		this.account = account;
		this.drawingMoney = drawingMoney;
	}
	//取钱
	@Override
	public void run() {
		synchronized(account)
		{
			//判断有没有钱
			if(account.money-drawingMoney<0)
			{
				System.out.println(Thread.currentThread().getName()+"钱不够");
				return;
			}
			//sleep可以放大问题的发生性
			try {
				Thread.sleep(1000);
			}catch(Exception e)
			{
				e.printStackTrace();
			}
			//卡内余额=余额-你取的钱
			account.money = account.money-drawingMoney;
			//你手里的钱
			nowMoney = nowMoney + drawingMoney;
			System.out.println(account.name+"余额为"+account.money);
			
			//这两个操作等价
			//System.out.println(this.getName()+Thread.currentThread().getName());
			System.out.println(this.getName()+"手里的钱"+nowMoney);	
		}
	}
}

运行结果（存款不会为负数了）：
在这里插入图片描述
3.线程不安全的集合

package demo3;
import java.util.ArrayList;
import java.util.List;
//线程不安全的集合
public class UnsafeList {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> list = new ArrayList<String>();
		for(int i=0;i<10000;i++)
		{
			new Thread(()->{
				list.add(Thread.currentThread().getName());
			}).start();
		}
		try {
			Thread.sleep(3000);
		}catch(Exception e)
		{
			e.printStackTrace();
		}
		System.out.println(list.size());
	}
}

运行结果（不足10000，因为存在两个线程同时看到一个标志，于是name就被覆盖掉了）：
在这里插入图片描述

package demo3;

import java.util.ArrayList;
import java.util.List;

//线程不安全的集合
public class UnsafeList {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> list = new ArrayList<String>();
		for(int i=0;i<10000;i++)
		{
			new Thread(()->{
				synchronized(list)
				{
					list.add(Thread.currentThread().getName());
				}
			}).start();
		}
		try {
			Thread.sleep(3000);
		}catch(Exception e)
		{
			e.printStackTrace();
		}
		System.out.println(list.size());
	}
}

运行结果（list.size（）=10000）：
在这里插入图片描述
4.2Lock锁
在这里插入图片描述
4.3synchronized和Lock锁的比较
在这里插入图片描述

5.线程池

在这里插入图片描述

	import java.util.concurrent.ExecutorService;
	import java.util.concurrent.Executors;
	
	public class TestPool {
	    public static void main(String[] args) {
	        // 1.创建服务，创建线程池
	        ExecutorService service = Executors.newFixedThreadPool(10);
	
	        // 执行
	        service.execute(new MyThread());
	        service.execute(new MyThread());
	        service.execute(new MyThread());
	        service.execute(new MyThread());
	
	        // 2.关闭连接
	        service.shutdown();
	    }
	}
	
	class MyThread implements Runnable{
	    @Override
	    public void run() {
	        System.out.println(Thread.currentThread().getName());
	    }
	}

运行结果：
在这里插入图片描述

6.线程间通信

概念：多个线程在处理同一个资源，但是处理的动作却不相同。
等待唤醒机制：多个线程间的协作机制。
wait(）：线程不再活动，不再参与调度。
notify(）：选取所通知对象的wait set 中的一个线程释放。
notifyall（）：释放所通知对象的wait set 中的全部线程。

让时间来沉淀吧
关注
专栏目录
Java多线程基础
m0_63989537的博客
08-31 330
Java线程的一些基础知识
Java多线程干货系列（1）Java多线程基础编程开发技术
11-22
Java多线程是Java编程中的重要...以上内容仅涵盖了Java多线程基础编程的一部分知识点，实际开发中还需要关注更多的并发控制策略、性能优化和调试技巧。对于深入理解Java多线程，还需要学习和实践更多相关的高级特性。
Java多线程-基础
weixin_44319442的博客
03-28 375
上下文切换 上下文切换指 cpu 从一个进程（或线程）切换到另一个进程（或线程）。上下文指某一时间点cpu 寄存器和程序计数器的内容。 上下文切换通常是计算密集型的，意味着此操作会消耗大量 cpu 时间，所以线程不是越多越好。 实现多线程方式 继承 Thread 类 实现 Runnable 接口 Thread类的几个常用方法： concurrentThread：返回当前正在执行的线程对象 start：开始执行线程，java虚拟机会调用 线程的 run 方法 yield：当前线程让出处理器的
Java多线程基础-01、数组概述.rar
11-20
本资料“Java多线程基础-01、数组概述”将带你入门Java的多线程世界，并结合数组这一基本数据结构进行讲解。 首先，我们需要理解什么是线程。线程是操作系统分配CPU时间的基本单位，一个进程可以有多个线程，它们...
Java 多线程基础笔记
最新发布
08-17
Java 多线程基础笔记
Java多线程基础-03、数组定义方式二、元素默认值规则.rar
11-20
总之，Java多线程基础是高效编程的关键，而理解数组定义和元素默认值规则则是构建安全、健壮的多线程程序的基础。通过合理运用多线程技术和掌握数组的内在特性，你可以编写出更加高性能、可扩展的Java应用程序。
一篇文章弄懂Java多线程基础和Java内存模型
12-21
Java多线程是并发编程的重要组成部分，理解和掌握其基础以及Java内存模型对于任何Java开发者来说都是必不可少的。本文将深入探讨这两个主题。 首先，我们来理解多线程的生命周期及其五种基本状态： 1. 新建状态...
java多线程基础
殷志鹏的博客
11-18 302
一、线程与进程，线程的实现方式 什么是线程？ 聊线程我们需要先知道什么是进程(进程包含线程，一个进程可以有多个线程，进程结束线程一定结束，线程结束，进程不一定结束) 进程：是当前正在执行的一个程序，比如我们同时运行了qq和微信，这两个程序就是两个独立的进程 进程是静态的执行过程 占用特定的内存空间 不同进程间相互独立，由cpu、内存地址code 和 内存空间data组成 一个单核cpu同一时刻只能处理一个进程，如果进程过多，cpu负担会很重，所以现在有很多4核，8核cpu来同时处理多个进程
尚硅谷_java多线程_学习笔记
qq_17079255的博客
10-08 1669
文章标题
Java多线程基础与实战
本文旨在介绍Java多线程的基础知识，包括线程的实现方式、线程同步以及线程状态等核心概念。" 在Java中，线程是一个程序执行的最小单元，它代表了进程中的单一控制流。与进程相比，线程更加轻量级，因为它们共享...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值