Java多线程——感知多线程和体验多线程

￡神魔★判官ぃ 2022-06-01 08:51 320阅读 0赞

一、感知多线程

进程：进行的程序，操作系统资源分配的单位。

线程：是进程中的执行路径，进程中的功能是靠进程中的多个线程执行的。

二、体验多线程

实现多线程的两种方式

1.继承Thread类，该子类重写Thread类的 run 方法。

package 多线程基础;
    
    public class Thread_Demo2 
    {
        public static void main(String [] args)
        {
        	new TestThread().start();   //激活一个线程
        	
        	for(int i=0;i<5;i++)
        	{
        		System.out.println("main线程在运行!");
        		try
        		{
        			Thread.sleep(1000);
        		}
        		catch(InterruptedException e)
        		{
        			e.printStackTrace();
        		}
        	}
        }
    }
    
    class TestThread extends Thread
    {
    	public void run()
    	{
    		for(int i=0;i<5;i++)
    		{
    			System.out.println("Threadtest在运行!");
    			
    			try
    			{
    				Thread.sleep(1000);
    			}
    			catch(InterruptedException e)
    			{
    				e.printStackTrace();
    			}
    		}
    	}
    }

输出：

main线程在运行!  
Threadtest在运行!  
main线程在运行!  
Threadtest在运行!  
Threadtest在运行!  
main线程在运行!  
Threadtest在运行!  
main线程在运行!  
Threadtest在运行!  
main线程在运行!

2.声明实现Runnable接口的类，该类然后实现 run 方法

package 多线程基础;
    
    public class RunnableThread {
    
    	public static void main(String[] args) 
    	{
    		ThreadinheritfromRunnable t=new ThreadinheritfromRunnable();
    		new Thread(t).start();//使用Thread类的start方法启动线程
    		
    		for(int i=0;i<5;i++)
    		{
    			System.out.println("main在运行!");
    			try {
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    
    	}
    }
    class ThreadinheritfromRunnable implements Runnable
    	{
    		public void run()
    		{
    			for(int i=0;i<5;i++)
    			{
    				System.out.println("TestThread在运行!");
    				
    				try {
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    	}

输出：

main在运行!  
TestThread在运行!  
main在运行!  
TestThread在运行!  
TestThread在运行!  
main在运行!  
main在运行!  
TestThread在运行!  
main在运行!  
TestThread在运行!

三、两种多线程机制的比较

1.使用Thread实现多线程模拟铁路售票系统

1）出错代码。原因：一个线程只能启动一次

Thread.currentThread().getName()用来获取当前线程的名称

package 多线程基础;
    
    public class ThreadDemo_4
    {
        public static void main( String[] args )
        {
            tTestThread t = new tTestThread();
            // 一个线程对象只能启动一次
            t.start();
            t.start();
            t.start();
            t.start();
        }
    }
    
    class tTestThread extends Thread
    {
        private int tickets = 5;
    
        public void run()
        {
            while( tickets > 0 )
            {
                System.out.println( Thread.currentThread().getName() + "出售票" + tickets );
                tickets -= 1;
            }
        }
    }

输出：

Exception in thread "main" Thread-0出售票5  
Thread-0出售票4  
Thread-0出售票3  
Thread-0出售票2  
Thread-0出售票1  
java.lang.IllegalThreadStateException  
at java.lang.Thread.start(Thread.java:708)  
at 多线程基础.ThreadDemo\_4.main(ThreadDemo\_4.java:10)

2）修改后的代码

package 多线程基础;
    
    public class ThreadDemo_3 {
    
    	public static void main(String[] args) {
    		//启动了4个线程
    	new TesttThread().start();
    	new TesttThread().start();
    	new TesttThread().start();
    	new TesttThread().start();
    	}
    
    }
    class TesttThread extends Thread
    {
    	private int tickets=5;
    	public void run()
    	{
    		while(tickets>0)
    		{
    			System.out.println(Thread.currentThread().getName()+"出售票"+tickets);
    			tickets--;
    		}
    	}
    }

输出：

Thread-3出售票5  
Thread-3出售票4  
Thread-3出售票3  
Thread-3出售票2  
Thread-2出售票5  
Thread-2出售票4  
Thread-2出售票3  
Thread-2出售票2  
Thread-2出售票1  
Thread-0出售票5  
Thread-1出售票5  
Thread-1出售票4  
Thread-1出售票3  
Thread-1出售票2  
Thread-1出售票1  
Thread-0出售票4  
Thread-3出售票1  
Thread-0出售票3  
Thread-0出售票2  
Thread-0出售票1

可见：每个线程有自己的资源，每个线程卖了5张票，一共卖了20张，与我们要求的4个线程一块卖5张票不符

3）使用Runnable接口实现多线程，并实现资源共享

package 多线程基础;
    
    public class RunnableDemo {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		
    		thread t=new thread();  //实例化Runnable的实现类对象thread对象
    		//启动四个线程，实现资源共享,都使用者一个对象  t 的run方法
    		new Thread(t).start();
    		new Thread(t).start();
    		new Thread(t).start();
    		new Thread(t).start();
    		
    	}
    
    }
    
    class thread implements Runnable
    {
    	private static int tickets=5;
    	
    	public void run()
    	{
    		while(tickets>0)
    		{
    			System.out.println(Thread.currentThread().getName()+"出售票"+tickets);
    			tickets--;
    		}
    	}
    }

输出：

Thread-1出售票5  
Thread-1出售票4  
Thread-1出售票3  
Thread-1出售票2  
Thread-1出售票1  
Thread-0出售票5  
Thread-3出售票5  
Thread-2出售票5

这样4个进程卖完了5张票，实现了资源共享的目的。可见，实现Runnable接口相对于继承Thread类来说，有以下几个显著的

优势。1）避免由于Java的单继承特性带来的局限。2）可以使多个线程共享相同的资源，以达到资源共享的目的。

但是，通过输出可以看见，第5张票被线程被多卖了3次，这是因为一个线程还没来得及更新tickets，它的时间片接到了，只得

退出CPU，让其他线程执行，而其他线程看见tickets依然是旧状态，所以依次把那张已经卖出的票再次“卖”了。

事实上，tickets属于临界资源（Critical resource），而run（）方法就属于临界资源区（Critical Section）。多个进程涉及到同

一个临界资源的临界区称为相关临界区。