Java学习--多线程

stray。。

已于 2022-11-24 20:47:55 修改

阅读量255

点赞数

文章标签： java 学习 jvm

于 2022-11-15 15:47:26 首次发布

本文链接：https://blog.csdn.net/m0_52585291/article/details/127866333

版权

关于线程：

线程就是独立的执行路径;
在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程;
main()称之为主线程,为系统的入口，用于执行整个程序;
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度,调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的。
对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制; 线程会带来额外的开销,如cpu调度时间，并发控制开销。
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

线程是程序中执行的线程。

创建线程方式一：

继承Thread类，重写run()方法，调用start开启线程。

package 多线程;

public class 创建线程 extends Thread  {
	

	@Override
	public void run() {
		//run方法线程体
		// TODO Auto-generated method stub
		for(int i=0;i<200;i++) {
			System.out.println("我在看代码"+i);
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//main线程，主线程 
		
		//创建一个线程对象
		创建线程 test1 = new 创建线程();
		
		test1.start();
		// 调用start方法
		for(int j=0;j<200;j++) {
			System.out.println("我在学习多线程"+j);
		}
	}
	//main线程与下面开启的线程对象同时交替运行，没有先后顺序

}

注：线程开启不一定立即执行，由CPU调度执行，没有固定先后顺序

原理图：两个线程同时进行，（单核电脑实际上是两个线程交替进行）
在这里插入图片描述

创建线程方法二：

声明实现Runnable接口

package 多线程;

public class second implements Runnable{

	

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<200;i++) {
			System.out.println("我在看代码"+i);
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//创建runnable接口的实现类对象
		second test2 = new second();
		//创建线程对象,通过线程对象开开启线程
		Thread thread = new Thread(test2);
		
		thread.start();
		for(int i=0;i<100;i++) {
			System.out.println("我在学习多线程。"+i);
		}
	}


}

方式一方式二总结：

在这里插入图片描述 补充：java静态变量只能初始化一次。

多个线程同时操作同一个对象。

用多线程实现土规赛跑

package 龟兔赛跑;

public class first  implements Runnable{

	private static String winner;

	@Override
	public void run() {
		// TODO Auto-generated method stub
		
		
		for(int i=1;i<=100;i++) {
			if(Thread.currentThread().getName().equals("兔子")) {
				try {
					Thread.sleep(1);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
					System.out.println("兔子睡了会");
				}
			}
			boolean flag = gameOver(i);
			if (flag) {
				break;
			}
			System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
			
		}
	}
	
	//判读是否完成比赛
	private boolean gameOver(int steps) {
		if(winner!=null) {
			return true;
		}
		if(steps>=100) {
			winner = Thread.currentThread().getName();
			System.out.println("winner is "+winner);
			return true;
		}
		
	
	return false;
	
	
	}
	public static void main(String[] args) {
		first test4 =  new first();
		
		new Thread(test4,"兔子").start();
		new Thread(test4,"乌龟").start();
	}
	}

线程礼让

礼让线程，让当前正在执行的线程暂停,但不阻塞
将线程从运行状态转为就绪状态
让cpu重新调度，礼让不一定成功!看CPU心情

public class TestYield {
 public static void main ( String [] args ){
 MyYield myYield = new MyYield ();
 new Thread ( myYield , name :" a ")· start ();
 new Thread ( myYield , name :" b "). start ();
 }
 }

class MyYield implements Runnable {
@override
 public void run (){
 System.out.println ("线程开始执行"); 
 Thread.yield();//礼让
 System.out.println ("线程停止执行");
 }
 }

线程强制执行
案例：

public class TestJoin implements Runnable {
goverride
public void run() {
for(inti=0;i<1000;i++){
System. out . print1n("线程vip来了"+i);
}
public static void main(String[] args) throws InterruptedException {
//启动我们的线程
TestJoin testJoin = new TestJoin();
Thread thread = new Thread (testJoin);
thread.start();
//主线程
for(inti=θ;i<500;i++){
if (i==200){
thread. join();//让其他进程插队，当其他进程运行完才继续本进程
System. out . println("main"+i);
}

观测线程状态

public static void main(String[] args) {
Thread thread = new Thread(()->{
for(inti=0;i<5;i++){
try {
Thread .sleep( millis: 1000) ;
} catch (InterruptedException e) {
e. pr intStackTrace();
}
}
system.out.print("");
});
//观察状态
Thread.state state = thread.getstate();//获取状态
System.out.println(state); //NEW

thread.start(); //线程启动
state = thread.getstate() ;//获取状态
System. out .println(state); //Run
while (state != Thread. State. TERMINATED){//只要上面的线程不终止,就一直输出状态
Thread. sleep( millis: 100);
state = thread. getstate(); //更新线程状态
Sys tem. out . pr intln(state); //赫出状态
}
}
}
});

注意：死亡之后的线程不能再被重新启动

线程的优先级
main方法的默认优先级为5

优先级越高，CPU就优先调度，但不是绝对

先设置优先级再启动，优先级大于1小于10

线程的优先级第只是意味着调度的概率低，并不是优先级第的就不会被调用了，这要看CPU的调度

public class Test10 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "主线程优先级: " + Thread.currentThread().getPriority());
        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        t1.start();
        t2.setPriority(1);
        t2.start();
        t3.setPriority(10);
        t3.start();
        t4.setPriority(9);
        t4.start();
        t5.setPriority(8);
        t5.start();
    }
}
class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "---优先级：" + Thread.currentThread().getPriority());
    }
}

守护线程：

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕
如，后台记录操作日志，监控内存，垃圾回收等待…

thread.setDaemon(true)//默认是false表示是用户线程，正常的线程都是用户线程

public static void main(String[] args) {
God god = new God() ;
You you = new You();
Thread thread = new Thread (god) ;
thread. setDaemon(true); 1/默认 是false表示是用户线程，正常的线程都是用户线程...
thread.start(); // 上帝守护线程启动
new Thread(you) .start(); //你 用户线程启动...
//上帝
class God implements Runnable{
@Override
public void run() {
while (true){
System. out .println("上帝保佑着你");
}
}
}

class You implements Runnable{
@Override
public void run() {
for(int i=0;i<36500;i++){
	System.out.println("你一生都开心的活着");
}
	System. out . println("-====goodbyel world======"); //Hello, World!
}
}

并发：
同一个对象被多个线程同时操作

由于同一进程的多个线程共享同一块存储空间,在带来方便的同时，也带来了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized ,当一个线程获得对象的排它锁, 独占资源, 其他线程必须等待，使用后释放锁即可.存在以下问题:
◆ 一个线程持有锁会导致其他所有需要此锁的线程挂起;
◆ 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时，引
起性能降低问题;
◆ 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒
置,引起性能问题

线程不安全

每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

关于读的例子

模拟银行取钱
每个线程获取银卡的余额状态决定自己是否进行取钱，当钱比自己要取得钱少时，不取，当钱足够时，取钱，并修改账户余额，当其中一个线程获取了账户余额，并且余额仅够他取时，在他还未修改账户余额时，另一个线程获取到了账户余额，该账户余额被重复获取了两次，最后造成账户余额变成了负数，造成线程不安全。

//取钱
@override
public void run() {
//判断有没有钱
if (account.money- drawingMoney<0) {
System. out . println(Thread. currentThread() . getName()+"钱不够,取不了");
return;
}
//sleep可以放大问题的发生性
try {
Thread.sleep( millis: 1000) ; .
} catch (InterruptedException e){
e. printStackTrace();
}
//卡内余额=余额-你取的钱
account .money = account .money - dr awingMoney;
//你手里的钱
nowMoney = nowMoney + drawingMoney;
System. out . println(account.name+"余额为: "+ account . money) ;
//Thread. currentThread(). getName() = this . getName()
System. out.println(this.getName() +"手里的钱:"+nowMoney) ;

买票

public class UnsafeBuyTicket {
 public static void main ( String [] args ){
 BuyTicket station = new BuyTicket ();
 new Thread ( station , name :"苦逼的我"). start ();
 new Thread ( station , name :"牛逼的你们"). start ();
 new Thread ( station , name :"可恶的黄牛党"). start ();
}
}

 class BuyTicket implements Runnablef {
// 票
 private int ticketNums =10;//票数
 boolean flag = true ;// 外部停止方式
@0verride
 public void run (){
// 买票
 while ( flag ){
 buy ()
 }
 }
private void buy () throws InterruptedException {

// 判断是否有票
 if ( ticketNums <=0){
 flag = false ; return ;}
// 模拟延时
 Thread.sleep ( milis :100);//进行放大线程不安全
// 买票
 System . out . println ( Thread . currentThread ()· getName ()+"拿到"+ ticketNums --);
 }
 }

当还剩一张票时，且其中一个线程获取到了，正准备更新余票数，库存数还未更改，这时另一个线程识别到库存中还有一张，也获取到了，这时两个线程都会对票数执行减操作，从而出现票数为负的情况。线程不安全。

关于写的例子：
比如两个线程在将数据写入同一个集合中去时，当两个线程都获取到了同一个存储空间，就行发生重复写的问题，其中一个数据被覆盖。

同步方法

◆由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：
synchronized 方法和synchronized 块
同步方法： public synchronized void method ( int args )}
◆ synchronized 方法控制对“对象”的访问，每个对象对应一把锁，每个
synchronized 方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获
得这个锁，继续执行
缺陷：若将一个大的方法申明为 synchronized 将会影响效率

方法里需要修改的内容才需要锁，锁太多，浪费资源。

同步方法：

public synchronized void method ( int args ) //加锁方式

例如：
上例中可修改为

private  synchronized void buy () throws InterruptedException {
。。。。。
}

每次只允许洗个进程执行buy（）函数。

同步块：
◆同步块： synchronized ( Obj )}
Obj 称之为同步监视器
◆ Obj 可以是任何对象，但是推荐使用共享资源作为同步监视器
◆同步方法中无需指定同步监视器，因为同步方法的同步监视器就是 this ，就是
这个对象本身，或者是 class ［反射中讲解】
◆同步监视器的执行过程
1．第一个线程访问，锁定同步监视器，执行其中代码
2．第二个线程访问，发现同步监视器被锁定，无法访问
3．第一个线程访问完毕，解锁同步监视器，
4．第二个线程访问，发现同步监视器没有锁，然后锁定并访问

// 线程不安全的集合
 public class UnsafeList {
 public static void main ( String [] args ){
 List < String > list = new ArrayList < String >;
  for ( int i =0; i <10000; i ++){
 	new Thread (()->{
		 synchronized ( list ){// synchronized 同步块
				 list.add ( Thread . current Thread ()· getName ());}
}).start ();
 try {
 	Thread . sleep ( milis :3000);
} catch ( InterruptedException e ){
 	e . printStackTrace ();}
 	
 System . out . println ( list . size ());

//取钱
@override
public void run() {
 synchronized (account){
//判断有没有钱
if (account.money- drawingMoney<0) {
System. out . println(Thread. currentThread() . getName()+"钱不够,取不了");
return;
}
//sleep可以放大问题的发生性
try {
Thread.sleep( millis: 1000) ; 
} catch (InterruptedException e){
e. printStackTrace();
}
//卡内余额=余额-你取的钱
account .money = account .money - dr awingMoney;
//你手里的钱
nowMoney = nowMoney + drawingMoney;
System. out . println(account.name+"余额为: "+ account . money) ;
//Thread. currentThread(). getName() = this . getName()
System. out.println(this.getName() +"手里的钱:"+nowMoney) ;
}

把run方法里的放在 synchronized (account) 块中。阻止其他进程对account对象进行访问。当大括号内的内容运行完毕才释放。

测试 JUC 安全类型的集合

//测试 JUC 安全类型的集合
 public class TestJUC {
 public static void main ( String [] args ){
Copy0nWriteArrayList< String > list = new Copy0nWriteArrayList< String >();//这个类本来就是安全的不用加锁。
 for ( int i =0; i <10000; i ++){
 new Thread (()->{
 list . add ( Thread . current Thread ()· getName ());
})· start ();

LOCK锁的用法

性能比 synchronized好

class A {
 private final ReentrantLock lock = new Reen TrantLock (); public void m (){
 lock . lock ();
 try {
1／保证线程安全的代码；
 finally {
 lock . unlock ();
1／如果同步代码有异常，要将 unlock (）写入 finally 语句块

 Lock （锁）

stray。。

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习--多线程

在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度,调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的。对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制;线程会带来额外的开销,如cpu调度时间，并发控制开销。在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程;继承Thread类，重写run()方法，调用start开启线程。每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。：线程开启不一定立即执行，有CPU调度执行，没有固定先后顺序。
复制链接

扫一扫