黑马程序员多线程（一）。

最新推荐文章于 2025-05-29 21:31:02 发布

原创最新推荐文章于 2025-05-29 21:31:02 发布 · 491 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了Java中多线程的基本概念及其实现方法，包括进程与线程的区别、线程的启动方式、多线程的两种实现方式及其区别，还探讨了多线程的安全问题及解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

多线程

进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序该顺序是一个执行路径，

或者叫一个控制单元。

线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。

线程在控制着进程的执行。一个进程中至少有一个线程。

java 虚拟机启动的时候，会有一个进程java.exe。该进程中至少有一个线程在负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称为主线程。

多线程实现的第一种方式（继承Thread）

java.lang 包 Thread类

java已经提供了对线程这类事物的描述，就是Thread类。

创建先线程的第一种方式：继承Thread类。

start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

class Demo extends Thread {             //Demo类继承Thread类
	public void run(){                  //复写run方法
		for (int x=0;x<=50 ;x++ )       //该线程执行的任务
			System.out.println("demo run---"+x);
	}
}

class ThreadDemo{
	public static void main(String[] args) {
		Demo d = new Demo();            //创建Demo类的对象
		d.start();                      //对象调用start方法启动线程，并进入就绪状态
		for (int x=0;x<=50 ;x++ )       //主线程执行的任务
			System.out.println("---main run---"+x);
	}
}

通过运行可以发现

每次运行结果都不同，是因为多个线程同时获取CPU执行权，CPU执行到谁，谁就运行。
可以形象的把多线程的运行行为看成是在互相争抢CPU的执行权。
在某一时刻，只能有一个程序在运行（多核CPU除外）。

因为CPU在各个线程中快速切换执行，所以看上去像是同时运行一样。
这就是多线程的一个特性：随机性。谁抢到谁执行，执行多长时间，CPU说了算。

run和start

Thread类用于描述线程，该类定义了一个功能，用于存储线程要运行的代码，

该存储功能就是run方法。也就是说Thread类中的run方法用于存储线程要运行的代码。

线程都有自己默认的名称：Thread-编号。该编号从0开始。

class Thread1 extends Thread {
	private String a=this.getName();//获取线程名称
	public void run() {
		for (int x=0;x<10 ;x++ )
			System.out.println(a+" 1111-"+x);
    }
}
class Thread2 extends Thread {
	private String a=this.getName();//获取线程名称
	public void run() {
		for (int x=0;x<10 ;x++ )
			System.out.println(a+" 2222-"+x);
    }
}
class  ThreadDemo1103 {
	public static void main(String[] args) {
        Thread1 t1 = new Thread1();
        Thread2 t2 = new Thread2();
        t1.start();
        t2.start();
		//t1.run();
        //t2.run();
        for (int x=0;x<10 ;x++ )
			System.out.println("Hello world----"+x);
	}
}

获取线程对象和名称

currentThread() 返回对当前正在执行的线程对象的引用。
setName() 设置线程名称。getName():获取线程名称。

System.currentTimeMillis(); 获取当前毫秒数。

System.nanoTime(); 获取当前毫微秒

*图图图*

多线程实现的第二种方式（实现Runnable接口）
    
     创建线程的第二中方式：实现Runnable接口
步骤：
1、该类实现Runnable接口
2、复写Runnable接口中的run方法。
3、通过Thread类建立线程对象。
4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
5、调用Thread类的start方法开启线程并调用Runnable接口的子类对象。
继承Thread和实现Runnable的区别：
    继承Thread：线程代码存放在Thread子类run方法中。无法多继承。
    实现Runnable：线程代码存放在接口的子类的run方法中。可以多实现。
实现Runnable的好处
    避免了单继承的局限性，在定义线程时，建议使用实现方式。
    
    
     练习 实现多个窗口买票
    
    
     思路  必须是多窗口同时卖固定数量的票。票不能有重复。
    
    
     //实现Runnable接口
class Ticket implements Runnable {
	//初始化票数。
    private static int tick = 100; 
	//复写Runnable接口的run方法
	public void run(){
		while(tick>0){
			if(tick>0){
                String WinName = Thread.currentThread().getName();
				System.out.println(WinName+"："+tick--);
			}
		}
	}
}
class TicketDemo{
	public static void main(String[] args){
		Ticket t = new Ticket();
		//在创建线程对象的同时，就指定run方法所属对象。
		//通过Thread类创建4个线程对象。表示四个售票窗口。
		//将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
        Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		
		//调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}
     多线程的安全问题
     
      通过运行结果可以看出来
      ，可能会打印出0，-1，-2 等错票，由此可见多线程出现了安全问题
     
     
      当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，
还没有执行完，另一个线程参与进来执行，导致共享数据的错误。

     
     
      怎么解决这个问题呢？
     
     
      对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其它线程能参与执行。

     
     
      
       同步代码块
      
       同步代码块：对于多线程的安全问题java提供了专业的解决方式。
       

      
      
       同步代码块原理：
用生活中的现象来说，比如在火车上上卫生间，如果门是关的，表示有人，就进不去，
如果门是开的，就进去后就把门关上，外面的人就进不去，只能等里面的人出来。

      
      同步代码块格式：
      

      synchronized(对象)
      

      {
      

       需要被同步的代码
      

      }
      

     
     
      
      class Ticket implements Runnable {
	private int tick = 100; 
    //创建obj对象只为了给synchronized使用。
	Object obj = new Object();
	public void run(){
		while(tick>0){
            //同步代码块
			synchronized(obj){
				if(tick>0){	
					//设置获得锁的线程的休眠时间。
					try{Thread.sleep(10);}catch(Exception e){}
					String tn = Thread.currentThread().getName();
					System.out.println(tn+" "+tick--);
				}
			}
		}
	}
}
class TicketDemo{
	public static void main(String[] args){
		Ticket t = new Ticket();
		//在创建线程对象的同时，就指定run方法所属对象。
		//通过Thread类创建4个线程对象。表示四个售票窗口。
		//将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

同步函数的锁是this

函数需要被对象调用，那么函数都有一个所属对象引用，就是this。
所以同步函数使用的锁就是this。
通过该程序进一步验证：
使用两个线程来卖票：
一个线程在同步代码中执行卖票动作，
一个线程在同步函数中执行卖票动作。

利用多窗口同时售票的例子进行同步函数方法修改

class Ticket implements Runnable {
	private int tick = 10000;
	public void run(){
		while(tick>0){
			show();
		}
	}
	public synchronized void show(){
		if(tick>0){	
			try{Thread.sleep(10);}catch(Exception e){}
			String aa = Thread.currentThread().getName();
			System.out.println(aa+" "+tick--);
		}
	}	
}
class ThisLockDemo{
	public static void main(String[] args){
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

未完待续。请转多线程（二）
---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------