java学习-多线程

已于 2023-04-22 01:40:51 修改
阅读量131 收藏
点赞数
分类专栏： java学习 文章标签： java
于 2023-04-16 15:47:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49349476/article/details/130157022
版权

（一）进程与线程

1、关于进程与线程

进程：代码在数据集合上的一次运行活动

线程：线程是进程中的一个实体

在Windows操作系统下可以通过Ctrl+Alt+Del组合键查看进程，在UNIX和 Linux操作系统下是通过ps命令查看进程的。打开Windows当前运行的进程：

2、关系进程与线程之间关系：

  • 线程属于进程的实体，也就是说明线程是必须依赖于进程
  • 进程里面至少有一个线程，没有线程此进程也无法运行
  • 一个进程允许有多个线程

3、主线程

Java程序至少会有一个线程，这就是主线程，程序启动后是由JVM创建主线程，程序结束时由JVM停 止主线程。主线程它负责管理子线程，即子线程的启动、挂起、停止等等操作。图23-2所示是进程、 主线程和子线程的关系，其中主线程负责管理子线程，即子线程的启动、挂起、停止等操作。

 

（二）创建线程的方法

Java中创建一个子线程涉及到：java.lang.Thread类和java.lang.Runnable接口。Thread是线程类，创建一 个Thread对象就会产生一个新的线程。而线程执行的程序代码是在实现Runnable接口对象的run()方法 中编写的，实现Runnable接口对象是线程执行对象。创建线程有三种方法，

方法一：继承Thread类​​​​​​​​​​​​​​

创建一个继承Thread的类，重写hread类中run的方法，调用Start方法

创建类：

public class MyThread extends Thread {
	public  void run() {  //重写Thread类的
		//线程功能实现
	}
	
}

创造线程

public class One {
	public static void main(String[] args) {
		MyThread mt=new MyThread(); //实例化对象 ,默认线程名字Thread-数字；
//		mt.start();//启动线程方式一
		mt.run();//启动线程方式二
		MyThread mt1=new MyThread();
		mt1.start();
	}
}

方法二  实现Runnable接口

Thread的构建参数：

Thread(Runnable target, String name)

分配一个新的 Thread对象。其中target是Runable类的对象，name是线程的名字

方法二与方法一不同的是：实现Runnable接口方式创建线程，能够实现多线程共享Runnable实现类对象

创造一个类，实现Runnable接口,然后重写run方法，

public class Mythread2  implements Runnable{
	public void run() { //重写run方法
		//线程功能实现
	}
}

在测试类中，用多态实例化Runnable类，再实例化Thread对象，把我们自建的Mythread2和Thread联系到一起，Runnable类是起到两个类连接的作用。

public static void main(String[] args) {
		
		Runnable r=new Mythread2();  //实例化线程对象  多态
		Thread t1=new Thread(r,"线程A");  //实话化Threa对象
		t1.start(); //启动线程A

		Thread t2=new Thread(r,"线程B");
		t2.start();
	}

还可以直接通过内部类实现。

不用创建类，直接在主类中通过内部类实现：

package Two;

public class LocalMyRunnable {

	public static void main(String[] args) {
		// 使用局部内部类
		Runnable r=new Runnable() {//实例化化
			public void run() { //重写run方法
				//线程功能实现
			}
		};
		Thread t1=new Thread(r,"线程A");
		t1.start();
		Thread t2=new Thread(r,"线程B");
		t2.start();
	}
}

也可以使用Lambad表达式实现

这个方法，在实例化Thread对象之后，不用重写run犯法

package Two;

public class LambdaRunnable {

	public static void main(String[] args) {
		// 通过Lambad表达式实现
        //  线程A创建  
		new Thread(()->{   
            //功能实现
			},"线程A").start();  //"线程A"是设置线程名，start方法表示创建即启用线程
		 //  线程B创建  
		new Thread(()->{
			//功能实现
		},"线程B").start();
	}

}

方法三：通过Callable接口实现

创建类

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {
	public  Integer call() throws Exception{ //重写call方法，类似run方法
		int sum = 0;

		//计算1到100的所有数之和
		for (int j = 1; j <=100; j++) {
			sum+=j;
			System.out.println("当前j的值："+j+",当前sum的值："+sum);
		}
		return sum;
	}
}
package Three;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class Three {

	public static void main(String[] args) {
		
		Callable <Integer>ca=new MyCallable();//多态实现实例化，
		Runnable r=new FutureTask<Integer>(ca);//实例化FuntureTask对象
		Thread t1=new Thread(r,"线程A");
		t1.start();
		
	}

}

Callable和Runnable接口的关系如下：

RunnableFuture接口是继承于Runnable接口，在Future类中实现，Future类中有一个构建方法，里面的参数是Callable接口类型的

  call方法和run方法的区别：
 1.run方法没有返回值，而call方法是可以有返回值
 2.run方法没有声明异常，而call方法有声明异常处理
 3.run方法不可以使用泛型，而call方法可以使用泛型

（三）线程的操作

1、线程睡眠：Thread.sleep

sleep(long millis)
使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性
public static void main(String[] args) {
		new Thread(new Runnable() {
			public void run() {
				for (int i = 1; i <=100; i++) {
					try {
						if(i==50) {
							System.out.println("线程睡眠了=================");
							//这里的单位是毫秒
							Thread.sleep(500); //睡眠，让当前线程暂停500毫秒，就意味着在这500毫秒时间内cpu不会再为当前线程提供服务，cpu就开始为别的线程提供服务
						}
						
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("当前线程："+Thread.currentThread().getName()+",当前变量i的值："+i);
				}
				
			}
		},"线程A").start();
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int j = 1; j <=100; j++) {
					System.out.println("当前线程："+Thread.currentThread().getName()+",当前变量i的值："+j);
				}
			}
		},"线程B").start();

		
	}

结果可以看得到，在i=50之后，设置线程睡眠，让A线程睡眠500毫秒，之后都是线程B在运行

2、线程加入：Tread.join

join()等待这个线程死亡
join(long millis)等待这个线程死亡最多 millis毫秒

Thread t1 = new Thread(new Runnable() {
			public void run() {
				for (int j = 1; j <=1000; j++) {
					System.out.println("当前线程："+Thread.currentThread().getName()+",当前变量i的值："+j);
					try {
						Thread.sleep(1);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				
			}
		},"线程B");
		t1.start();
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int i = 1; i <=200; i++) {
					if(i==20) { //当线程A的i循环到20的时候，线程B就强制插队进来了
						try {
							//t1.join(); //无参的不管线程A有没有执行完，必须要等到线程B执行结束，才可能再次执行线程A
							t1.join(10); //单位是毫秒，线程B插队进来，在10毫秒内cpu全部给线程B服务，10毫秒时间一到，不管线程B有没有执行完，cpu就不再独享给线程B了，也有可能给线程A服务
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
					System.out.println("当前线程："+Thread.currentThread().getName()+",当前变量i的值："+i);
				}
				
			}
		},"线程A").start();

结果如下，可以看到

 

3、线程守护： setDaemon(true)

setDaemon(boolean on)
将此线程标记为 daemon线程或用户线程。

此方法不是静态方法，需要实例化对象。

Thread t1 = new Thread(new Runnable() {
			public void run() {
				for (int i = 1; i <=10000; i++) {
					System.out.println("当前线程："+Thread.currentThread().getName()+",当前变量i的值："+i);
				}
				
			}
		},"线程A--守护线程");
		
		Thread t2 = new Thread(new Runnable() {
			public void run() {
				for (int j = 1; j <=100; j++) {
					System.out.println("当前线程："+Thread.currentThread().getName()+",当前变量i的值："+j);
				}
				
			}
		},"线程B--用户线程");
		//把t1线程设置为守护线程
		t1.setDaemon(true); //放在线程启动之前设置，才会生效
		t1.start();
		t2.start();

结果如下：当线程用户线程B未执行之前，用户线程B和守护线程A相互交错执行，但在用户线程B执行结束之后，守护线程A执行一段时间之后，就停止，之所以不立马停止是因为，用户线程停止的信号向守护线程A传递需要一点时间，而在这段时间内，守护线程会继续执行。

4、线程优先级：getPriority()与setPriority()

setPriority(int newPriority)

更改此线程的优先级。
getPriority()

返回此线程的优先级。

newPriority取值的方法：

a、1~10，1的优先级最小，10的优先级最大（默认是5）

b、MIN_PRIORITY的优先级是1 MAX_PRIORITY的优先级是10

Thread t1 = new Thread(new Runnable() {
			public void run() {
				for (int i = 1; i <=100; i++) {
					System.out.println("当前线程："+Thread.currentThread().getName()+",当前变量i的值："+i);
				}
			}
		},"线程A");
		
		Thread t2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int j = 1; j <=100; j++) {
					System.out.println("当前线程："+Thread.currentThread().getName()+",当前变量i的值："+j);
				}
				
			}
		},"线程B");
		
//		查看优先级
		System.out.println("线程t1的优先级："+t1.getPriority());
		System.out.println("线程t2的优先级："+t2.getPriority());
		//设置线程的优先级，并不能达到100%，它只是一种概念，优先级高的线程获得cpu的概念会更高一些。
		t1.setPriority(7);
		t2.setPriority(3);
		//t1.setPriority(Thread.MIN_PRIORITY); //1
		//t2.setPriority(Thread.MAX_PRIORITY); //10
		t1.start();
		t2.start();
		System.out.println("设置优先级之后：");
		System.out.println("线程t1的优先级："+t1.getPriority());
		System.out.println("线程t2的优先级："+t2.getPriority());

结果如下：设置优先级之后，线程A的优先级小于B,所以大部分是A线程先执行

5、线程礼让：Thread.yield()

yield()

对调度程序的一个暗示，即当前线程愿意产生当前使用的处理器。


线程礼让不是绝对的，有两种可能：
1、礼让成功：由对方线程获得cpu执行权
2、礼让失败：本线程再次获得了cpu执行权
线程礼让，当前线程没有进入阻塞状态，而是直接进入到了就绪状态，而睡眠是直接进入到了阻塞状态
 

public static void main(String[] args) {
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int i = 1; i <=100; i++) {
					if(i%5==0) {
						Thread.yield();
						System.out.println("线程A礼让======");
					}
					System.out.println("当前线程："+Thread.currentThread().getName()+",当前变量i的值："+i);
				}
				
			}
		},"线程A").start();
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int j = 1; j <=100; j++) {
					System.out.println("当前线程："+Thread.currentThread().getName()+",当前变量i的值："+j);
					if(j%5==0) {
						Thread.yield();
						System.out.println("线程B礼让======");
					}
				}
				
			}
		},"线程B").start();
	
		
	}

（四）线程安全

1、线性安全面临的问题

在多线程环境下，访问相同的资源，有可能会引发线程不安全问题。例如，当多线程中都共享同一个资源，数据之间需要共享，而且都需要执行写操作。一个线程A访问资源时，还没完全的完成整一个写操作，如果此时，有另有一个线程B也访问了这个资源，两个线程同时访问同一个资源，这会照成资源数据不正确，

有个购票案例如下：

public class TicketThread  extends Thread {

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

	public static int tickets = 100; // 总共有100张票

	public void run() {
		// 模拟不同的售票容器售卖这100张票的情况
		while (true) {
			if (tickets <= 0) {
				break;
			}
			System.out.println(super.getName() + ":正在售卖第" + (101 - tickets) + "票。。。");
			// 模拟网络延迟
			try {
				Thread.sleep(50);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			tickets--;
		}
	}

}
public static void main(String[] args) {
		new TicketThread("深圳站").start();
		new TicketThread("广州站").start();
		new TicketThread("东莞站").start();
		
	}

运行结果如下：结果会有同一票会有不同的对象同时购买到，这就是线程不安全问题

 2、解决多线程问题的方法

解决多线程问题的方法就是线程同步，java提供一种互斥机制，就是在资源对象加上一把"互斥锁"，在任意时刻只能由一个线程访问，即使线程出现阻塞，该对象的被锁状态也不会解除，其他线程仍不能访问该对象，这就是多线程同步。

有三种方法可以完成同步操作：

a、同步代码块

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

//锁对象的采取有三种方法
//1、如果线程采用实现Runnalbe接口的方式，可以用this
//2、object对象
//3、java的类对象：类.class

 有个售票案例如下：

public class TicketThread2  extends Thread {

public int tickets = 100; // 总共有100张票
	
	Object obj = new Object();
	public void run() {
		// 模拟不同的售票容器售卖这100张票的情况
		while (true) {
			//如果采用实现Runnalbe接口的方式的话，这里就可以使用this关键字
			//this代表当前类的对象的引用
			//synchronized (this) {
			//换成obj也是可以的
			//synchronized (obj) {
			//类对象的方式，原因是因为类的类对象在jvm内存中有且只有一个
			//java中的类对象，专门用来描述类的一个类
			synchronized (TicketThread2.class) {
				//同步代码块是放的是我们想要锁住的内容
				if (tickets <= 0) {
					break;
				}
				System.out.println(Thread.currentThread().getName() + ":正在售卖第" + (101 - tickets) + "票。。。");
				// 模拟网络延迟
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				tickets--;
			}
		}
	}
}

实现类：

public static void main(String[] args) {
		
		TicketThread2 t = new TicketThread2();
		new Thread(t,"深圳站").start();
		new Thread(t,"广州站").start();
		new Thread(t,"东莞站").start();
		
	}

结果如下：

b、同步方法

synchronized关键字修饰方法实现线程同步，方法所在的对象被锁定

public synchronized void 方法名() {
        //同步代码块
	}

​​​​​​​

public class TicketThread2  extends Thread {
public int tickets = 100; // 总共有100张票
	
	boolean flag = true;
	//同步方法也是有锁对象的，默认的
	//如果同步方法是非静态方法，它的锁对象就是this
	//如果同步方法是静态方法，它的锁对象就是当前方法所在的类的类对象TicketThread2.class
	//同步方法
	public synchronized void saleTicket() {
			if (tickets > 0) {
				System.out.println(Thread.currentThread().getName() + ":正在售卖第" + (101 - tickets) + "票。。。");
				// 模拟网络延迟
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				tickets--;
			}else {
				flag = false;
			}
	}

	public void run() {
		// 模拟不同的售票容器售卖这100张票的情况
		while (true) {
			if(flag) {
				saleTicket();
			}else {
				break;
			}
			
		}
		
	}
}

实例化：

public static void main(String[] args) {
		
		TicketThread2 t = new TicketThread2();
		new Thread(t,"深圳站").start();
		new Thread(t,"广州站").start();
		new Thread(t,"东莞站").start();
		
	}

结果：

c、锁机制

Lock锁也称同步锁，加锁与释放锁方法化了，当使用lock方法时，资源就被锁住，只能由当前访问的对象进行继续访问，其他的对象不能对其进行访问，当执行unlock方法时，才会释放资源

Lock lock = new ReentrantLock();//1实例化一个锁对象

lock.lock();    // 2、对象锁住
//此处放需要同步的代码块

lock.unlock();  //3、对像释放
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TicketThread2  extends Thread {
	private int tickets = 10; // 总共10张票
	Lock lock = new ReentrantLock();// 实例化一个显示锁的对象
	public void run() {
		while (true) {
			try {
				lock.lock(); // 获得锁对象
				if (tickets <= 0) {
//					 lock.unlock();
					break;// 使用完了，要记得释放锁对象
				}
				System.out.println(Thread.currentThread().getName() + "抢到第" + (11 - tickets) + "张票,剩余" + (tickets - 1) + "张票！");
				Thread.sleep(100);// 模拟网络延迟
				tickets--;
			} catch (InterruptedException e) {
				e.printStackTrace();
			} finally {
				lock.unlock();// 使用完了，要记得释放锁对象
			}
		}

	}
}
public static void main(String[] args) {
		TicketThread2 tt = new TicketThread2();
		new Thread(tt,"桃跑跑").start();
		new Thread(tt,"黄牛党").start();
		new Thread(tt,"张票票").start();
		
	}

(五)等待唤醒机制

线程中的通信：可以完成线程协作，多个线程同时运行，每个线程能够运行是随机的,在上面的许多案例中可以发现。如果需要线程之间有序进行运行，这需要等待唤醒机制

纪水一
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值