Java-多线程

一：目录：

1.线程概述；

2.线程的创建方式；

3.常用API；

4.线程安全问题；

5.死锁问题；

二：线程概述：

Java是一种多线程编程语言，它允许程序同时执行多个任务。线程是程序中执行的单个独立的路径，每个线程都有自己的指令序列和栈。线程可以同时执行不同的任务，从而提高程序的并发性和效率。

Java中的线程是通过创建Thread类的实例来实现的。可以通过继承Thread类并重写run()方法来创建线程，也可以实现Runnable接口并传递给Thread类的构造函数来创建线程。

Java中的线程具有以下特点：

1. 并发执行：多个线程可以同时执行，提高程序的运行效率。

2. 共享资源：线程可以共享程序的数据和资源，但需要遵循适当的同步机制，以免出现数据竞争和不一致的问题。

3. 线程调度：线程调度器决定了线程的执行顺序，可以通过设置线程的优先级来指定执行顺序。

4. 线程同步：Java提供了多种同步机制，如互斥锁、信号量、条件变量等，用于保护共享资源的访问，防止出现竞态条件和死锁等问题。

5. 线程间通信：线程可以通过共享变量、管道、消息队列等实现信息的交换和通信。

Java中的线程可以分为两类：用户线程和守护线程。用户线程是程序中的主要线程，它负责执行程序的主要逻辑。守护线程是在后台执行的线程，当所有的用户线程都结束时，守护线程会自动退出。

Java提供了丰富的线程相关的API，包括线程创建、启动、停止、等待、同步等操作。开发者可以利用这些API来实现复杂的多线程应用程序。同时，Java还提供了一些高级的线程库，如线程池、并发集合等，用于简化线程编程的复杂性。

三：线程的创建方式：

1.继承Thread类：

package Test;

public class test4 {
	public static void main(String [] args) {
		new my(100).start();
	}
}
class my extends Thread{
	int n;
	public my(int n)
	{
		this.n=n;
	}
	public void run()
	{
		int sum=0;
		for(int i=1;i<=this.n;i++)
		{
			sum=sum+i;
		}
		System.out.println(sum);
	}
}

缺点很明显：继承了Thread，就不能再继承其他类了，受到限制。

2.实现Runnable接口：

package Test;

public class test4 {
	public static void main(String [] args) {
		my m=new my(100);
		Thread thread=new Thread(m);
		thread.start();
	}
}
class my implements Runnable{
	int n;
	public my(int n)
	{
		this.n=n;
	}
	public void run()
	{
		int sum=0;
		for(int i=1;i<=this.n;i++)
		{
			sum=sum+i;
		}
		System.out.println(sum);
	}
}

优点：可以继承其他类，Runnable为函数式接口，可以使用匿名内部类。

3.实现Callable接口：

package Test;

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

public class test4 {
	public static void main(String [] args) throws Exception {
		my m=new my(100);
		FutureTask futureTask=new FutureTask(m);
		Thread thread=new Thread(futureTask);
		thread.start();
		System.out.println(futureTask.get());
	}
}
class my implements Callable{
	int n;
	public my(int n)
	{
		this.n=n;
	}
	@Override
	public Object call() throws Exception {
		// TODO 自动生成的方法存根
		int sum=0;
		for(int i=1;i<=this.n;i++)
		{
			sum=sum+i;
		}
		return sum;
	}
}

与上面两个的区别：有返回值，接口中方法是call()，需要建立FutureTast对象进行过渡。

 FutureTest类：

 四：常用API：

start（）	启动一个新线程，在新的线程运行run方法中的代码
run（）	新线程启动后会调用的方法
join()	等待被调用线程运行结束
join(long millis)	等待线程运行结束,最多等待 millis毫秒
join(long millis,int nanos)	等待线程运行结束,最多等待 millis毫秒，nanos纳秒
getId()	获取线程长整型的 id
getName()	获取线程名
setName(String name)	修改线程名
getPriority()	获取线程优先级
setPriority(int newPriority)	修改线程优先级(1低-10高)
static yield()	提示线程调度器让出当前线程对CPU的使用
static sleep(long millis)	使得当前线程阻塞millis毫秒
static sleep(long millis, int nanos)	使得当前线程阻塞millis毫秒加上nanos纳秒
static currentThread()	获取当前正在执行的线程
isAlive()	判断线程存活状态
interrupt()	打断线程
isInterrupted()	判断是否被打断
static interrupted()	判断当前线程是否被打断
getState()	获取线程状态

五：线程安全问题：

1.问题描述：

线程安全问题是指在多线程环境中，多个线程同时对同一数据进行读写操作时可能出现的问题。线程安全的代码能够保证在多线程环境下，数据不会被破坏或产生不一致的结果。

线程安全问题常见的表现形式有以下几种：

1. 竞态条件（Race Condition）：多个线程对同一个共享资源进行读写操作，导致最终结果依赖于线程执行的顺序。

2. 死锁（Deadlock）：多个线程互相等待对方释放资源而无法继续执行。

3. 数据不一致（Data Inconsistency）：多个线程同时对同一数据进行写操作，导致最终结果不一致。

4. 并发访问问题（Concurrent Access）：多个线程同时访问同一个对象或方法，导致数据错乱或异常。 

 对此，我们模拟一个取钱问题：

package Test;
class Bank{
	private int id;
	private int money;
	public Bank(int id,int money) {
		this.id=id;
		this.money=money;
	}
	public void getmoney(int money1)
	{
		String nameString=Thread.currentThread().getName();
		if(this.money>=money1)
		{
			System.out.println(nameString+"来取钱"+money1+"成功");
			this.money-=money1;
			System.out.println(nameString+"来取钱后,余额剩余"+this.money);
		}
		else
			System.out.println(nameString+"来取钱，余额不足");
		}
}
class myThread extends Thread{
	private Bank bank;
	public myThread(Bank bank,String name) {
		super(name);
		this.bank = bank;
	}

	public void run()
	{
		bank.getmoney(10000);
	}
}
public class test4 {
	public static void main(String [] args) throws Exception {
		Bank bank=new Bank(1111100,10000);
		Thread thread=new myThread(bank, "李华");
		Thread thread2=new myThread(bank,"小红");
		thread.start();
		thread2.start();
	}
}

我们模拟了一个简易的银行系统，和一个简易的取钱系统，并让两口子李华和小红同时来取钱。

  结果如下：

可以看出这里出现了线程安全问题，李华取钱成功后，小红来取时，并没有提示余额不足，而是出现的负余额。 

2.解决方法(加锁synchronized)：

1.同步代码块：

public void getmoney(int money1)
{
	String nameString=Thread.currentThread().getName();
	synchronized (this) {
	if(this.money>=money1)
	{
		System.out.println(nameString+"来取钱"+money1+"成功");
		this.money-=money1;
		System.out.println(nameString+"来取钱后,余额剩余"+this.money);
	}
	else
		System.out.println(nameString+"来取钱，余额不足");
	}	
}

 只需将取钱的过程实现步骤的代码块锁住就解决了线程安全问题。

同步代码块中的参数问题：①：在静态方法中使用synchronized(类名.class)修饰;

                                           ②：在非静态方法中使用synchronized(this)修饰。 

2.同步方法：

public synchronized void getmoney(int money1)
{
	String nameString=Thread.currentThread().getName();
	if(this.money>=money1)
	{
		System.out.println(nameString+"来取钱"+money1+"成功");
		this.money-=money1;
		System.out.println(nameString+"来取钱后,余额剩余"+this.money);
	}
	else
		System.out.println(nameString+"来取钱，余额不足");
}

 结果如下：

 六：死锁问题：

产生死锁的四个必要条件
1.互斥使用：当 t1 线程拿到了锁，t2 如果也想拿，必须等着，等 t1 释放了(锁的基本特性)

2.不可抢占：t1 拿到了锁，必须由 t1 主动释放，t2 不能强行获取锁！

3.保持和请求：t1 拿到了锁 A，再拿到了 B 的锁，此时 A 这把锁还是保持的(不会因为获取到了锁 B 就把 锁 A 给释放了)

4.循环等待：当 t1 尝试获取锁A和B，t2也尝试获取锁B和A，如果 t1 获取到锁A，t2 获取到锁B，此时 t1 就会等待 t2 释放锁B，而 t2 也会等待 t1 释放锁 A

所以只要打破这四条的任意一条，就能让死锁消失，但前三条对于 synchronized 来说，都是基本的特性，修改不了，而循环等待上述唯一一个和代码结构相关的，也是可以控制的！

所以解决死锁最简单可靠的办法，就是打破循环等待！