Java自带线程分析软件 java 线程分析

1，线程与进程

进程：正在运行的程序，独立

线程：进程的执行单位，相互独立

关系：一个进程可以拥有多个线程，一个线程必须有一个父进程

注意：

1，线程拥有自己的堆栈，程序计数器和局部变量，但不拥有系统资源，

与父进程的其他线程共享该进程所拥有的全部资源。

2，线程执行是抢占式的，当前任何运行的线程都有可能被挂起。

3，一个线程可以创建和撤销另一个线程，同一进程中的多个线程可以并发执行。

总结：

操作系统可以同时执行多个任务，每个任务就是进程，进程可以同时执行多个任务，每个人任务都是线程

2，线程创建和启动

//一共3个线程，一个主线程加两个子线程 extends Thread
public class FirstThread extends Thread
{
	private int i ;
	public void run()
	{
		for ( ; i < 100 ; i++ )
		{
			System.out.println(getName() +  " " + i);
		}
	}
	public static void main(String[] args)
	{
		for (int i = 0; i < 100;  i++)
		{
			System.out.println(Thread.currentThread().getName()+  " " + i);
			if (i == 20)
			{
				//创建并启动第一个线程
				new FirstThread().start();
				//创建并启动第2个线程
				new FirstThread().start();
			}
		}
	}
}

// implements Runnable
public class SecondThread implements Runnable
{
	private int i ;
	public void run()
	{
		for ( ; i < 100 ; i++ )
		{
			System.out.println(Thread.currentThread().getName()+ "  " + i);
		}
	}

	public static void main(String[] args)
	{
		for (int i = 0; i < 100;  i++)
		{
			System.out.println(Thread.currentThread().getName()+ "  " + i);
			if (i == 20)
			{
				SecondThread st = new SecondThread();     
				new Thread(st).start();
				new Thread(st).start();
			}
		}
	}
}

// Callable接口创建
public class ThirdThread
{
	public static void main(String[] args)
	{
		ThirdThread rt = new ThirdThread();

		FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>)() -> {
			int i = 0;
			for ( ; i < 100 ; i++ )
			{
				System.out.println(Thread.currentThread().getName());
			}
			return i;
		});
		for (int i = 0 ; i < 100 ; i++)
		{
			System.out.println(Thread.currentThread().getName());
			if (i == 20)
			{
				new Thread(task).start();
			}
		}
		try
		{
			System.out.println(task.get());
		}
		catch (Exception ex)
		{
			ex.printStackTrace();
		}
	}
}

3，线程生命周期

4，控制线程

线程A调用线程B，阻塞调用线程A，等线程B完成以后，再继续调用线程A

5，线程同步

——-——线程安全问题解决方案

与同步代码块对应， Java 多线程安全支持还提供了同步方法，同步方法就是使用 synchronized

键字来修饰某个方法，则该方法称为同步方法。

逻辑：加锁——修改锁——释放锁

class X {
//定义锁对象
	private final ReentrantLock lock =new ReentrantLock(); 
	//定义需要保证线程安全的方法
		public void m () {
		//加锁
			lock.lock() ; 
		try {
		//需要保证线程安全的代码
			// . .. method body 
		//使用 f 工 nally 块来保证释放锁
		finally {
			lock.unlock()
		}
	}
}

当两个线程相互等待对方释放同步监视器时就会发生死锁。

一旦出现死锁 整个程序既不会发生任何异常，也不会给出任何提示，只是所有线程处于阻塞状态 无法继续。