java-多进程,多线程

Posted 2021-09-03 Ocean:)

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java-多进程,多线程相关的知识，希望对你有一定的参考价值。

多进程,多线程

线程

线程使用的是系统资源,该系统资源是操作系统分配给当前进程使用的,多个线程的情况下,同时[抢占执行]会导致资源紧缺

一个Java程序,最少有2个线程:

main线程
JVM的GC机制,守护线程

并行和并发

并发

两个或者两个以上的十五在同一个时间段发生
并行

两个或者两个以上的事务在同一个时刻发生

宏观并行,微观串行
高并发

在一个时间段内,发生众多事情

多线程

优缺点

优点:

提升资源利用率
提高用户体验

缺点:

降低了其他线程的执行概率
用户会感受到软件的卡顿问题
增加了系统资源压力
多线程情况下的共享资源问题,线程冲突,线程安全问题

创建线程

class Thread

Java中的一个线程类

Thread类是Runnable接口的实现类,同时提供了很多线程的操作使用的方法
interface Runnable接口

规定了what will be run?

里面只有一个run方法

创建自定义线程类的方式

自定义线程类,继承Thread类,重写run方法

创建自定义线程对象,直接调用start方法,开启线程
自定义线程类,遵从Runnable接口

使用自定义遵从接口Runnable实现类对象,作为Thread构造方法参数

借助于Thread类对象和start方法,开启线程

package cn.ocean888;

/*
 * 方法1
 * 继承Thread类自定义线程类
 */
class MyThread1 extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("继承Thread类自定义线程类");
		}
	}
}

/*
 * 方法2
 * 自定义线程类MyThread2遵从Runable接口
 */
class MyThread2 implements Runnable {
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("自定义线程类MyThread2遵从Runable接口");
		}
	}
}


public class Demo {
	public static void main(String[] args) {
		// 1.创建一个继承Thread类自定义线程类对象
		MyThread1 myThread1 = new MyThread1();
		// 这里不是启动线程,而是将run方法作为一个普通方法执行
		// myThread1.run()
		
		// 正确方法
		myThread1.start();
		
		
		
		// 2.创建一个Thread类对象,使用遵从Runnable接口的实现类作为构造方法参数
		Thread thread = new Thread(new MyThread2());
		// 借助于Thread类内的start方法开启线程
		thread.start();
		
		
		
		// 3.匿名内部类方法
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				System.out.println("匿名内部类方式创建对象,作为线程执行代码");
			}
		}).start();
	}
}

Thread类需要了解的方法

构造方法Constructor

Thread();

分配一个新的线程对象,无目标,无指定名字,存在默认名字
Thread(Runnable target);

创建一个新的线程对象,并且在创建线程对象的过程中,使用Runnable接口的实现类对象作为执行的线程代码块目标
Thread(String name);

创建一个新的线程,无指定目标,但是指定当前线程的名字
Thread(Runnable target, String name);

创建一个线程的线程对象,使用Runnable接口实现类对象,作为执行目标,并且指定name作为线程名

成员方法

void setName(String name);
String getName();

以上两个是name属性setter和getter属性
void setPriority(int Priority);

设置线程的优先级,非一定执行要求,只是增加执行的概率

优先级数值范围[1-10] 10 最高,1最低,5默认
int getPriority();

获取线程优先级
void start();

启动线程对象
public static void sleep(int ms);

当前方法是静态方法,通过Thread类调用,要求是当前所在线程代码块对应的线程进行休眠操作,指定休眠指定的毫秒数
public static Thread currentThread();

当前方法是静态方法,通过Thread类调用,获取当前所处代码快对应的线程对象

构造方法实例:

package cn.ocean888;

public class Demo1 {
	public static void main(String[] args) {
		Thread thread1 = new Thread();
		
		// 约束线程的名字
		Thread thread2 = new Thread("ocean线程");
		
		// 给予Thread类构造方法Runnable接口实现类对象
		Thread thread3 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				System.out.println("匿名内部类作为线程的执行目标");
			}
		});
		
		// 给予Thread类构造方法Runnable接口实现类对象,并且约定名字
		Thread thread4 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				System.out.println("匿名内部类作为线程的执行目标");
			}
		}, "匿名内部类对象");
		
		System.out.println(thread1);
		System.out.println(thread2);
		System.out.println(thread3);
		System.out.println(thread4);
		
	}
}

分别代表

Thread[ThreadName, ThreadPriority, ThreadGroup]

成员方法实例:

package cn.ocean888;

public class Demo2 {
	public static void main(String[] args) {
		Thread thread = new Thread(new Runnable() {
			
			@Override
			public void run() {
				System.out.println("线程目标代码");
			}
		}, "ocean线程");
		
		Thread currThread = Thread.currentThread();
		
		System.out.println(thread.getName());
		thread.setName("ocean线程2");
		System.out.println(thread.getName());
		
		System.out.println(thread.getPriority());
		/*
		 * 优先级范围1-10
		 * Thread.MAX_PRIORITY 最大优先级10
		 * Thread.MIN_PRIORITY 最小优先级1
		 * Thread.NORM_PRIORITY 默认优先级5
		 */
		thread.setPriority(Thread.NORM_PRIORITY);
		System.out.println(thread.getPriority());
	}
}

线程安全问题和解决方案

线程安全问题-共享资源能使用问题

局部变量

在方法内,如果run方法执行,存在,run方法当前执行完毕,销毁

每一个线程对象中都有run方法,无法满足共享问题
成员变量

每一个线程对象中,都有一个对应的成员变量,非共享资源
静态成员变量

属于类变量,所有的当前类对象,使用的静态成员变量都是一个,而且一处修改,处处受影响[共享资源]

线程抢占实例:

package cn.ocean888;

class SingleThread implements Runnable{
	private static int ticket = 100;

	@Override
	public void run() {
		while (true) {
			try {
				Thread.sleep(100);
			} catch (Exception e) {
				e.printStackTrace();
			}
			
			if (ticket > 0) {
				System.out.println(Thread.currentThread().getName() + "抢走了第" + ticket + "张票");
				ticket -= 1;
			} else {
				System.out.println(Thread.currentThread().getName() + "售罄");
				break;
			}
		}
	}
	
	
}

public class Demo3 {
	public static void main(String[] args) {
		Thread thread1 = new Thread(new SingleThread(), "淘票票");
		Thread thread2 = new Thread(new SingleThread(), "飞猪");
		Thread thread3 = new Thread(new SingleThread(), "美团");

		thread1.start();
		thread2.start();
		thread3.start();
	}
}

会出现三个线程同时抢一张票

甚至会出现抢超过100张票

同步代码块

synchronized(/* 锁对象 */) {

}

特征:

synchronized小括号里面的对象是锁对象,并且要求如果是多线程的情况下,锁对象必须是同一个对象
synchronized大括号中的代码块就是需要进行同步的代码,或者说是加锁的代码,打括号里面的内容,有且只允许一个线程进入
同步代码块越短越好,在保证安全的情况下,提高性能

实例:

class SingleThread implements Runnable{
	private static int ticket = 100;

	@Override
	public void run() {
		while (true) {
			synchronized ("lock") {
				try {
					Thread.sleep(10);
				} catch (Exception e) {
					e.printStackTrace();
				}
				
				if (ticket > 0) {
					System.out.println(Thread.currentThread().getName() + "抢走了第" + ticket + "张票");
					ticket -= 1;
				} else {
					System.out.println(Thread.currentThread().getName() + "售罄");
					break;
				}
			}
		}
	}	
}

缺点:

锁对象很随意,有隐患
代码层级关系复杂

同步方法

synchronized作为关键字来修饰方法,修饰的方法就是对应的同步方法

有且只允许一个线程进入

静态成员方法

锁对象是当前类对应的字节码文件类名.class
非静态成员方法

锁对象是当前类对象 this

静态成员方法实例:

package cn.ocean888;

class SingleThread2 implements Runnable{
	private static int ticket = 100;

	@Override
	public void run() {
		while (true) {
			sellTicket();
		}
	}
	
	
	public static synchronized void sellTicket() {
		if (ticket > 0) {
			System.out.println(Thread.currentThread().getName() + "售出了" + ticket + "第张票");
			ticket -= 1;
			
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} else {
			System.out.println(Thread.currentThread().getName() + "售罄");
		}
	}
	
}


public class Demo4 {
	public static void main(String[] args) {
		Thread thread1 = new Thread(new SingleThread2(), "淘票票");
		Thread thread2 = new Thread(new SingleThread2(), "飞猪");
		Thread thread3 = new Thread(new SingleThread2(), "美团");

		thread1.start();
		thread2.start();
		thread3.start();
	}
}

非静态成员方法实例:

package cn.ocean888;

class SingleThread implements Runnable{
	private static int ticket = 100;

	@Override
	public void run() {
		while (true) {
			sellTicket();
		}
	}
	
	
	public synchronized void sellTicket() {
		if (ticket > 0) {
			System.out.println(Thread.currentThread().getName() + "售出了" + ticket + "第张票");
			ticket -= 1;
			
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} else {
			System.out.println(Thread.currentThread().getName() + "售罄");
		}
	}
	
}


public class Demo3 {
	public static void main(String[] args) {
		SingleThread singleThread = new SingleThread();
		Thread thread1 = new Thread(singleThread, "淘票票");
		Thread thread2 = new Thread(singleThread, "飞猪");
		Thread thread3 = new Thread(singleThread, "美团");

		thread1.start();
		thread2.start();
		thread3.start();
	}
}

总结

如果非static修饰,要保证执行的线程对象有且只有一个,因为锁对象就是当前线程对象
如果是static修饰,锁对象具有唯一性,多个线程使用的锁是同一个锁

Lock锁

Java提供了一个对于线程安全问题,加锁操作相对于同步代码块方法更加广泛

对象化操作

创建Lock构造方法

Lock lock = new ReentrantLock();
方法化操作

开锁:unlock();

加锁:lock();

package cn.ocean888;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class SingleThread3 implements Runnable{
	private static int ticket = 100;

	static Lock lock = new ReentrantLock();
	@Override
	public void run() {
		while (true) {
			lock.lock();
			
			if (ticket > 0) {
				System.out.println(Thread.currentThread().getName() + "售出了" + ticket + "第张票");
				ticket -= 1;
				
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			} else {
				System.out.println(Thread.currentThread().getName() + "售罄");
				break;
			}
			
			lock.unlock();
		}
	}
}


public class Demo5 {
	public static void main(String[] args) {
		SingleThread3 singleThread3 = new SingleThread3();
		Thread thread1 = new Thread(singleThread3, "淘票票");
		Thread thread2 = new Thread(singleThread3, "飞猪");
		Thread thread3 = new Thread(singleThread3, "美团");

		thread1.start();
		thread2.start();
		thread3.start();
	}
}

三种加锁方式总结

一锁一线程,一所多线程问题

使用对应的锁操作对应的线程，考虑静态和非静态问题

同步方法和Lock锁使用

静态是一锁多目标,非静态是一锁一目标
涉及到同步问题时，要考虑好锁对象的选择问题
同步代码块，同步方法，Lock对象

守护线程

守护线程，也称之为后台线程，如果当前主线程崩掉，守护线程也会退出

守护线程一般用于:

自动下载
操作日志
操作监控

方法是通过线程对象

setDeamon(boolean flag);

true 为守护线程

false 缺省属性,正常线程

实例:

package cn.ocean888;

class BackUpThread implements Runnable {
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			try {
				Thread.sleep(100);
			} catch (Exception e) {
				e.printStackTrace();
			}
			
			System.out.println("Loading ..." + i + "%");
			
			if (100 == i) {
				System.out.println("Loading Complete ...");
			}
		}
	}
}

public class Demo6 {
	public static void main(String[] args) throws InterruptedException {
		Thread thread = new Thread(new BackUpThread());
		
		// 当前线程作为一个守护线程使用
		thread.setDaemon(true);
		thread.start();
		
		for (int i = 0; i < 50; i++) {
			Thread.sleep(100);
			System.out.println("主线程运行中...");
		}
	}
}

当主线程结束,守护线程也会结束

线程状态

6种状态

线程如果按照java.lang.Thread.State枚举方式来考虑,一共提供了6种状态

状态	导致状态的发生条件
NEW(新建)	线程刚刚被创建，没有启动，没有调用start方法
RUNNABLE(可运行)	线程已经可以在JVM中运行，但是是否运行不确定，看当前线程是否拥有CPU执行权
BLOCKED(锁阻塞)	当前线程进入一个同步代码需要获取对应的锁对象，但是发现当前锁对象被其他线程持有，当前线程会进入一个BLOCKED。如果占用锁对象的线程打开锁对象，当前线程持有对应锁对象，进入Runnable状态
WAITING(无限等待)	通过一个wait方法线程进入一个无限以上是关于java-多进程,多线程的主要内容，如果未能解决你的问题，请参考以下文章 Java多线程概述及创建线程学习知识点总结多个请求是多线程吗多线程编程多线程编程 python多线程 (c)2006-2024 SYSTEM All Rights Reserved IT常识