有关线程问题的简单小结，程序，进程，线程之间的关系等

最新推荐文章于 2022-04-16 16:20:25 发布

原创最新推荐文章于 2022-04-16 16:20:25 发布 · 199 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#多线程 #java #编程语言 #多进程

线程专栏收录该内容

1 篇文章

订阅专栏

本文详细解析了程序、进程和线程的概念及其相互关系，介绍了线程的创建方式和常用方法，探讨了线程优先级、同步机制及线程间的通信，并通过实例展示了线程的应用。

程序、进程、线程之间的区别与联系：

程序：一段静态的代码
进程: 静态的代码动态的执行过程，包括产生，执行，消亡。有自己的一块存储空间
线程：是进程内最小的执行单位，动态的执行过程在进程里面，共享进程里面的资源

线程创建的两种方式：

1、继承Thread类：线程

2、实现Runnable接口：不是线程，只是用来解决相关的问题

线程的常用方法：

currentThread()可以返回段正在被哪个线程调用的信息

getName(）得到线程的名字

getId（）得到线程的ID

isAlive（）判断线程是否可用

sleep（）线程休眠的方法

join 等待线程执行完毕

setDeamo（true）设置守护线程

线程的优先级：

不同的优先级：高优先级先执行，低优先级后执行

同一优先级：先到先服务

线程优先级的规范：系统默认和认为设置

线程同步：

多个线程操作同一个共享变量时，可能会导致共享变量的不完整（不安全）

为了保证共享变量的安全，可以使用同步机制保证共享变量的安全性

同步机制：当一个线程改变共享变量值时，其他线程不能使用共享变量，当线程计算完成，返回变量值之后，其他线程才可以使用共享变量。

使用synchronized关键值可以实现线程同步。

同步块synchronized的语法 synchronized{与共享变量相关业务的代码（运算）} 在方法上synchronized用次关键字修饰的方法叫同步方法。

同步线程之间的通信：

wait（）：线程进入等待池，等待其他别的线程唤醒。
notify（）：唤醒等待池中的一个线程。
notifyAll（）：唤醒等待池中的所有线程

案例：

1、用两种方法创建两个线程，一个打印10以内的偶数，一个打印10以内的奇数

class Runnable1 implements Runnable{   //函数式接口 
    public void run() {
		for(int i=0;i<=10;i++) {
			if(i%2==0) {
				System.out.println(i);
			}
		}
	}
	
}

public class Demo {
	public static void main(String[] args) {
            Runnable r1=new Runnable1();
		Thread t1=new Thread(r1);
		t1.start();
		
		Thread t2=new Thread(
				()->{
					for(int i=0;i<=10;i++) {
						if(i%2!=0) {
							System.out.println(i);
						}
					}
					
				}
				);
		t2.start();
	}

}

2、倒计时过年

public class Demo3 {
	/**
	 * sleep(毫秒)：线程休眠
	 * 如果休眠的过程中被唤醒，会抛出InterruptedException
	 * @param arg
	 *
	 */
	public static void main(String[] args) {
            new Thread(
				()->{
					                            System.out.println(Thread.currentThread().getName());
					for(int i=10;i>=1;i--) {
						System.out.println(i);
						try {
							Thread.sleep(800);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
					System.out.println("过年了！");
				},"倒计时开始：").start();
	              
    }
			
}

3、守护线程

public class Demo5 {
	public static void main(String[] args) {
		Thread rose=new Thread() {
			@Override
			public void run() {
				for(int i=1;i<=3;i++) {
					System.out.println("一起跳！");
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
				}
				System.out.println("扑通！");
			}
		};
		
		Thread jack=new Thread(
				()->{
					while(true) {
						System.out.println("你先跳，我再跳！");
						try {
							Thread.sleep(1000);
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
				}
				
				); 
		rose.start();
		jack.setDaemon(true);  //在线程启动之前设置线程为守护线程
		jack.start();
		};
				
	
}

4、三个线程交替执行

class Bank{
	private int money=1000;
	public synchronized void save(int money) {
		for(int i=1;i<=3;i++) {
			this.money+=money;
			System.out.println(Thread.currentThread().getName()+"余额:"+this.money);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}
public class Demo9 {
	public static void main(String[] args) {
		Bank bank=new Bank();
		Thread t1=new Thread(()-> {
			bank.save(100);
		});
		Thread t2=new Thread(()-> {
			bank.save(500);
		});
		t1.start();
		t2.start();
	}
	

}