Java基础-多线程

最新推荐文章于 2024-07-20 14:23:18 发布
最新推荐文章于 2024-07-20 14:23:18 发布
阅读量288 收藏
点赞数
分类专栏： Java 文章标签： java 多线程

多线程在Java中就是指并发机制，表示能够在同一时间内执行多个操作。本文目录结构如下：

  • 什么是多线程
  • 多线程的定义与使用
  • 多线程的生命周期
  • 线程的调度
  • 后台线程（Daemon Thread）
  • 多线程的同步问题
1 基本概念
    在总结Java中的多线程知识这一块，首先应该明确一些概念，如进程跟线程、并行与并发、线程安全、同步等。
    进程：具有一定独立功能的程序关于某个数据集合上的一次运行活动
    线程：系统进行资源分配和调度的一个独立单位.
    并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时；
    并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。
    线程安全：经常用来描绘一段代码。指在并发的情况之下，该代码经过多线程使用，线程的调度顺序不影响任何结果。这个时候使用多线程，我们只需要关注系统的内存，cpu是不是够用即可。反过来，线程不安全就意味着线程的调度顺序会影响最终结果，如不加事务的转账代码： 
void transferMoney(User from, User to, float amount){
  to.setMoney(to.getBalance() + amount);
  from.setMoney(from.getBalance() - amount);
}
    同步：Java中的同步指的是通过人为的控制和调度，保证共享资源的多线程访问成为线程安全，来保证结果的准确。如上面的代码简单加入@synchronized关键字。在保证结果准确的同时，提高性能，才是优秀的程序。线程安全的优先级高于性能。


2 多线程的定义与使用
    Java中线程的创建与启动常见有3种基本形式
  • 继承Thread类，重写该类的run方法   
class MyThread extends Thread {
     
     private int i = 0;
 
     @Override
     public void run() {
         for (i = 0; i < 100; i++) {
             System.out.println(Thread.currentThread().getName() + " " + i);
         }
     }
 }
public class ThreadTest {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName());
		Thread myThread1 = new MyThread();     // 创建一个新的线程  myThread1  此线程进入新建状态
		Thread myThread2 = new MyThread();     // 创建一个新的线程 myThread2 此线程进入新建状态
		myThread1.start();                     // 调用start()方法使得线程进入就绪状态
		myThread2.start();                     // 调用start()方法使得线程进入就绪状态
	}
}
      在重写的run（）方法中可以定义该线程所要执行的语句，称之为线程执行体。当创建此线程类对象时一个新的线程得以创建，并进入到线程新建状态。通过调用线程对象引用的start()方法，使得该线程进入到就绪状态，此时此线程并不一定会马上得以执行，这取决于CPU调度时机。

  • 实现Runable接口，并重写run()方法
  class MyRunnable implements Runnable {
      private int i = 0;
  
      @Override
      public void run() {
          for (i = 0; i < 100; i++) {
              System.out.println(Thread.currentThread().getName() + " " + i);
          }
      }
 }
public class ThreadTest {
	public static void main(String[] args) {
		System.out.println(Thread.currentThread().getName());
		Runnable myRunnable = new MyRunnable(); 	// 创建一个Runnable实现类的对象
		Thread thread1 = new Thread(myRunnable); 	// 将myRunnable作为Thread target创建新的线程
		Thread thread2 = new Thread(myRunnable);
		thread1.start(); 				// 调用start()方法使得线程进入就绪状态
		thread2.start();
	}
}
     该run()方法同样是线程执行体，创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。


     Thread和Runnable的关系，如下代码 
public class ThreadTest {
	public static void main(String[] args) {
		System.out.println(Thread.currentThread().getName());
		Runnable myRunnable = new MyRunable();
		Thread thread = new MyThread(myRunnable);
		thread.start();
	}
}

public class MyRunable implements Runnable{
	private int i;
	@Override
	public void run() {
		System.out.println("in MyRunnable run");
		for (i = 0; i < 50; i++) {
			System.out.print("#");
		}
	}
}

public class MyThread extends Thread{
	public MyThread(Runnable runnable){
		super(runnable);
	}
	@Override
	public void run() {
		for (int i = 0; i < 50; i++) {
			System.out.print("&");
		}
	}	
}
执行结果：
main
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
上述给到的例子中，由于多态的存在，根本就没有执行到Thread类中的run()方法，在Thread类的实现类MyThread中，实现了run方法，故直接先执行了MyThread类中的run()方法。
  • 使用Callable和Future接口创建线程
public class ThreadTest {
	public static void main(String[] args) {
		System.out.println(Thread.currentThread().getName());
		
		Callable<Integer> myCallable = new MyCallable();    // 创建MyCallable对象
		FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象
		
		Thread thread = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程
		thread.start();                   //线程进入到就绪状态
		 
		try {
			int sum = ft.get(); 			// 取得新创建的新线程中的call()方法返回的结果
			System.out.println("sum = " + sum);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
	}
}

public class MyCallable implements Callable<Integer> {
	private int i = 0;
	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for (; i < 50; i++) {
			System.out.println(Thread.currentThread().getName() + " " + i);
			sum += i;
		}
		return sum;
	}
}
     过程大致是创建Callable接口的实现类MyCallable ，并实现call()方法。并使用FutureTask类来包装Callable实现类的对象，以此FutureTask对象作为Thread对象的target来创建线程。
     在实现Callable接口中，线程执行体是call()方法，同时还具有返回值。在创建新的线程时，通过FutureTask来包装MyCallable对象，同时FutureTask作为了Thread对象的target。事实上，FutureTask类同时实现了Runnable和Future接口，由此使得其具有Future和Runnable双重特性。通过Runnable特性，可以作为Thread对象的target，而Future特性，使得其可以取得新创建线程中的call()方法的返回值。注意的是：通过ft.get()方法获取子线程call()方法的返回值时，当子线程此方法还未执行完毕，ft.get()方法会一直阻塞，直到call()方法执行完毕才能取到返回值。 

     上述主要讲解了三种常见的线程创建方式，对于线程的启动而言，都是调用线程对象的start()方法，需要特别注意的是： 不能对同一线程对象两次调用start()方法。

3 多线程的生命周期



    新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();在新建状态的线程对象严格意义上还只是一个线程对象，并不是一个独立的线程。
   就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程表明此线程已经做好准备，随时等待CPU调度执行。
   运行状态（Running）：处于就绪状态的线程一旦被选中，线程获取了CPU时间，此时线程真正得以执行，即进入到运行状态。线程进入到运行状态后也不是一下执行结束的，在运行状态下随时都可能被调度程序调度回就绪状态或者进入到阻塞状态。注：任何线程要想进入运行状态执行，首先必须处于就绪状态中；
    阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的占用权转而停止执行，此时进入阻塞状态。处于阻塞状态的线程被解除后不会立即回到运行状态，而是先进入就绪状态，等待系统的调度。根据阻塞产生的原因不同，阻塞状态又可以分为三种：
  • 等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
  • 同步阻塞：线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；
  • 挂起阻塞：运行状态的线程如果执行了其suspend方法，就会处于挂起阻塞状态，一直到调用其resume方法才会进入到就绪状态；
  • 其他阻塞：通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
   死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。


4 线程的调度
     通过系统自动调度机制，线程的执行顺序是没有保障的。java中给出了一些线程调度的方法，使用这些方法可以在一定程度上对线程进行调度，但是这些方法只是给线程调度的一个建议。具体是否可以成功执行是没有保障的。线程调度常用方法：睡眠、设置优先级、让步等。
  • 睡眠sleep()方法
      让当前的正在执行的线程暂停指定的时间，并进入阻塞状态。在其睡眠的时间段内，该线程由于不是处于就绪状态，因此不会得到执行的机会。即使此时系统中没有任何其他可执行的线程，出于sleep()中的线程也不会执行。因此sleep()方法常用来暂停线程执行。
      前面有讲到，当调用了新建的线程的start()方法后，线程进入到就绪状态，可能会在接下来的某个时间获取CPU时间片得以执行，如果希望这个新线程必然性的立即执行，直接调用原来线程的sleep(1)即可 
public class ThreadTest {

    public static void main(String[] args) {

        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                thread.start();
                try {
                    Thread.sleep(1);   // 使得thread必然能够马上得以执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
//注：睡一个毫秒级够了，因为CPU不会空闲，会切换到新建的线程。
class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
}
  • 设置优先级
     每个线程在执行时都具有一定的优先级，优先级高的线程具有较多的执行机会。 具有较高线程优先级的线程对象仅表示此线程具有较多的执行机会，而非优先执行。每个线程默认的优先级都与创建它的线程的优先级相同。main线程默认具有普通优先级。设置线程优先级：setPriority(int priorityLevel)。参数priorityLevel范围在1-10之间，常用的有如下三个静态常量值：
         MAX_PRIORITY:10
         MIN_PRIORITY:1
         NORM_PRIORITY:5
     获取线程优先级：getPriority()。 
public class ThreadTest {

    public static void main(String[] args) {
        Thread myThread = new MyThread();
        for (int i = 0; i < 100; i++) {
            System.out.println("main thread i = " + i);
            if (i == 20) {
                myThread.setPriority(Thread.MAX_PRIORITY);
                myThread.start();
            }
        }
    }

}

class MyThread extends Thread {

    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("i = " + i);
        }
    }
}
  • yield()让步方法
     yield()方法与线程优先级有关，当某个线程调用yiled()方法从运行状态转换到就绪状态后，CPU从就绪状态线程队列中只会选择与该线程优先级相同或优先级更高的线程去执行。当调用线程的yield()方法时，线程从运行状态转换为就绪状态，但接下来CPU调度就绪状态中的哪个线程具有一定的随机性，因此，可能会出现A线程调用了yield()方法后，接下来CPU仍然调度了A线程的情况。 
public class ThreadTest {

    public static void main(String[] args) {
        Thread myThread1 = new MyThread1();
        Thread myThread2 = new MyThread2();
        myThread1.setPriority(Thread.MAX_PRIORITY);
        myThread2.setPriority(Thread.MIN_PRIORITY);
        for (int i = 0; i < 100; i++) {
            System.out.println("main thread i = " + i);
            if (i == 20) {
                myThread1.start();
                myThread2.start();
                Thread.yield();
            }
        }
    }

}

class MyThread1 extends Thread {

    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("myThread 1 --  i = " + i);
        }
    }
}

class MyThread2 extends Thread {

    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("myThread 2 --  i = " + i);
        }
    }
}
  • join()让步方法
     让一个线程等待另一个线程完成才继续执行。如A线程线程执行体中调用B线程的join()方法，则A线程被阻塞，知道B线程执行完为止，A才能得以继续执行。 
public class ThreadTest {

    public static void main(String[] args) {

        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                thread.start();
                try {
                    thread.join();    // main线程需要等待thread线程执行完后才能继续执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
}


5 后台线程（Daemon Thread）
      后台线程主要是为其他线程（相对可以称之为前台线程）提供服务，或“守护线程”。如JVM中的垃圾回收线程。后台线程的生命周期与前台线程生命周期有一定关联。主要体现在：当所有的前台线程都进入死亡状态时，后台线程会自动死亡。
     设置后台线程：调用Thread对象的setDaemon(true)方法可以将指定的线程设置为后台线程。判断线程是否是后台线程：调用thread对象的isDeamon()方法。 

public class ThreadTest {

    public static void main(String[] args) {
        Thread myThread = new MyThread();
        for (int i = 0; i < 100; i++) {
            System.out.println("main thread i = " + i);
            if (i == 20) {
                myThread.setDaemon(true);
                myThread.start();
            }
        }
    }

}

class MyThread extends Thread {

    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("i = " + i);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
     注：main线程默认是前台线程，前台线程创建的子线程默认是前台线程，后台线程中创建的线程默认是后台线程。调用setDeamon(true)方法将前台线程设置为后台线程时，需要在start()方法调用之前。前台线程都死亡后，JVM通知后台线程死亡，但从接收指令到作出响应，需要一定的时间。

     由于实际的业务需要，常常会遇到需要在特定时机终止某一线程的运行，使其进入到死亡状态。目前最通用的做法是设置一boolean型的变量，当条件满足时，使线程执行体快速执行完毕。如： 
public class ThreadTest {

    public static void main(String[] args) {

        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                thread.start();
            }
            if(i == 40){
                myRunnable.stopThread();
            }
        }
    }
}

class MyRunnable implements Runnable {

    private boolean stop;

    @Override
    public void run() {
        for (int i = 0; i < 100 && !stop; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }

    public void stopThread() {
        this.stop = true;
    }

}

6 多线程的同步问题
  • 示例
public class ThreadTest {

    public static void main(String[] args) {
        Account account = new Account("123456", 1000);
        DrawMoneyRunnable drawMoneyRunnable = new DrawMoneyRunnable(account, 700);
        Thread myThread1 = new Thread(drawMoneyRunnable);
        Thread myThread2 = new Thread(drawMoneyRunnable);
        myThread1.start();
        myThread2.start();
    }

}

class DrawMoneyRunnable implements Runnable {

    private Account account;
    private double drawAmount;

    public DrawMoneyRunnable(Account account, double drawAmount) {       
        this.account = account;
        this.drawAmount = drawAmount;
    }

    public void run() {
        if (account.getBalance() >= drawAmount) {  //1
            System.out.println("取钱成功， 取出钱数为：" + drawAmount);
            double balance = account.getBalance() - drawAmount;
            account.setBalance(balance);
            System.out.println("余额为：" + balance);
        }
    }
}

class Account {

    private String accountNo;
    private double balance;

    public Account() {

    }

    public Account(String accountNo, double balance) {
        this.accountNo = accountNo;
        this.balance = balance;
    }

    public String getAccountNo() {
        return accountNo;
    }

    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

}
     上面例子很容易理解，有一张银行卡，里面有1000的余额，程序模拟两个人几乎同时在取款机进行取钱操作的场景。多次运行此程序，可能具有多个不同组合的输出结果。其中一种可能的输出为：
        取钱成功， 取出钱数为：700.0
       余额为：300.0
       取钱成功， 取出钱数为：700.0
      余额为：-400.0
     也就是说，对于一张只有1000余额的银行卡，一共可以取出1400，这显然是有问题的。经过分析，问题在于Java多线程环境下的执行的不确定性。CPU可能随机的在多个处于就绪状态中的线程去切换处于运行状态的线程，因此很有可能出现如下情况：当thread1执行到//1处代码时，判断条件为true，此时CPU切换到thread2，执行//1处代码，发现依然为真，然后执行完thread2，接着切换到thread1，接着执行完毕。此时，就会出现上述结果。
     因此，讲到线程安全问题，其实是指多线程环境下对共享资源的访问可能会引起此共享资源的不一致性。因此，为避免线程安全问题，应该避免多线程环境下对此共享资源的并发访问。

  • 同步方法
     对共享资源进行访问的方法：定义中加上synchronized关键字修饰，此方法称为同步方法。可以简单理解成对此方法进行了加锁，其锁对象为当前方法所在的对象自身。多线程环境下，当执行此方法时，首先都要获得此同步锁（且同时最多只有一个线程能够获得），只有当线程执行完此同步方法后，才会释放锁对象，其他的线程才有可能获取此同步锁，以此类推...
     在上例中，共享资源为account对象，当使用同步方法时，可以解决线程安全问题。只需在run()方法前加上synshronized关键字即可。 
class DrawMoneyRunnable implements Runnable {

    private Account account;
    private double drawAmount;

    public DrawMoneyRunnable(Account account, double drawAmount) {       
        this.account = account;
        this.drawAmount = drawAmount;
    }

    public synchronized void run() {
        if (account.getBalance() >= drawAmount) {  //1
            System.out.println("取钱成功， 取出钱数为：" + drawAmount);
            double balance = account.getBalance() - drawAmount;
            account.setBalance(balance);
            System.out.println("余额为：" + balance);
        }
    }
}
  • 同步代码块
     正如上面所分析的那样，解决线程安全问题其实只需要限制对共享资源的访问的不确定性即可。使用同步方法时，整个方法都成为了同步执行状态，有可能出现同步范围过大的情况。可以直接用另一种方式——同步代码块。
     同步代码块的格式为： 
 synchronized (obj) {
             
     //...
 
}
     这其中obj为锁对象，一般情况下，选择共享资源对象作为锁对象。如上例中，选用account对象作为锁对象就很好
  • Lock对象同步锁
     使用Lock对象同步锁可以方便解决“同步锁对象与共享资源解耦，同时很好的解决了线程安全问题”，唯一需要注意的一点是Lock对象需要与资源对象同样具有一对一的关系。Lock对象同步锁一般格式为： 
class X {
    
    // 显示定义Lock同步锁对象，此对象与共享资源具有一对一关系
    private final Lock lock = new ReentrantLock();
    
    public void m(){
        // 加锁
        lock.lock();
        
        //...  需要进行线程安全同步的代码
        
        // 释放Lock锁
        lock.unlock();
    }
    
}
  • wait()/notify()/notifyAll()线程通信
      这三个方法主要都是用于多线程中，但实际上都是Object类中的本地方法。因此，理论上，任何Object对象都可以作为这三个方法的主调，在实际的多线程编程中，只有同步锁对象调这三个方法，才能完成对多线程间的线程通信。

     wait()：导致当前线程等待并使其进入到等待阻塞状态。直到其他线程调用该同步锁对象的notify()或notifyAll()方法来唤醒此线程。
     notify()：唤醒在此同步锁对象上等待的单个线程，如果有多个线程都在此同步锁对象上等待，则会任意选择其中某个线程进行唤醒操作，只有当前线程放弃对同步锁对象的锁定，才可能执行被唤醒的线程。
     notifyAll()：唤醒在此同步锁对象上等待的所有线程，只有当前线程放弃对同步锁对象的锁定，才可能执行被唤醒的线程。 

public class ThreadTest {
	public static void main(String[] args) {
		Account account = new Account("123456", 0);
		Thread drawMoneyThread = new DrawMoneyThread("取钱线程", account, 700);
		Thread depositeMoneyThread = new DepositeMoneyThread("存钱线程", account, 700);
		
		drawMoneyThread.start();
		depositeMoneyThread.start();
	}
}

public class DrawMoneyThread extends Thread {
	private Account account;
	private double amount;
	
	public DrawMoneyThread(String threadName,Account account,double amount) {
		super(threadName);
		this.account = account;
		this.amount = amount;
	}
	
	@Override
	public void run() {
		for (int i = 0; i < 50; i++) {
			 account.draw(amount, i);
		}
	}
}

public class DepositeMoneyThread extends Thread {
	private Account account;
	private double amount;

	public DepositeMoneyThread(String threadName, Account account, double amount) {
		super(threadName);
		this.account = account;
		this.amount = amount;
	}

	@Override
	public void run() {
		for (int i = 0; i < 60; i++) {
			account.deposite(amount, i);
		}
	}
}

class Account{
	private String accountNo;
	private double balance;
	private boolean flag = false;			//标识账户中是否已有存款
	
	public Account() {
	}
	public Account(String accountNo, double balance) {
		this.accountNo = accountNo;
		this.balance = balance;
	}
	public String getAccountNo() {
		return accountNo;
	}
	public void setAccountNo(String accountNo) {
		this.accountNo = accountNo;
	}
	public double getBalance() {
		return balance;
	}
	public void setBalance(double balance) {
		this.balance = balance;
	}
	
	/**
	 * 存钱
	 */
	public synchronized void deposite(double depositeAmount, int i) {
		if (flag) { // 账户已经有人存钱
			try {
				System.out.println(Thread.currentThread().getName() + " 开始要执行wait操作" + " -- i=" + i);
				this.wait();
				System.out.println(Thread.currentThread().getName() + " 执行了wait操作" + " -- i=" + i);
			} catch (Exception e) {
				e.printStackTrace();
			}
		} else {
			// 开始存钱
			System.out.println(Thread.currentThread().getName() + " 存款:" + depositeAmount + " -- i=" + i);
			setBalance(balance + depositeAmount);
			flag = true;
			// 唤醒其他线程
			this.notifyAll();
			// 2
			try {
				Thread.sleep(3000);
			} catch (Exception e2) {
				e2.printStackTrace();
			}
			 System.out.println(Thread.currentThread().getName() + "-- 存钱 -- 执行完毕" + " -- i=" + i);
		}

	}
	
	/**
	 * 取钱
	 * @param drawAmount
	 * @param i
	 */
	 public synchronized void draw(double drawAmount, int i) {
		 if(!flag){			//账户还没有存钱进去
			 try {
				 System.out.println(Thread.currentThread().getName() + " 开始要执行wait操作" + " 执行了wait操作" + " -- i=" + i);
				 this.wait();
				 System.out.println(Thread.currentThread().getName() + " 执行了wait操作" + " 执行了wait操作" + " -- i=" + i);
			} catch (Exception e) {
				e.printStackTrace();
			}
		 }else{
			 // 开始取钱
			 System.out.println(Thread.currentThread().getName() + " 取钱：" + drawAmount + " -- i=" + i);
			 setBalance(getBalance() - drawAmount);
			 flag = false;
			 // 唤醒其他线程
			 this.notifyAll();
			 System.out.println(Thread.currentThread().getName() + "-- 取钱 -- 执行完毕" + " -- i=" + i); // 3
		 }
	 }
}

部分运行结果： 
存钱线程 存款:700.0 -- i=0
存钱线程-- 存钱 -- 执行完毕 -- i=0
存钱线程 开始要执行wait操作 -- i=1
取钱线程 取钱：700.0 -- i=0
取钱线程-- 取钱 -- 执行完毕 -- i=0
取钱线程 开始要执行wait操作 执行了wait操作 -- i=1
存钱线程 执行了wait操作 -- i=1
存钱线程 存款:700.0 -- i=2
存钱线程-- 存钱 -- 执行完毕 -- i=2
取钱线程 执行了wait操作 执行了wait操作 -- i=1
取钱线程 取钱：700.0 -- i=2
取钱线程-- 取钱 -- 执行完毕 -- i=2
取钱线程 开始要执行wait操作 执行了wait操作 -- i=3
存钱线程 存款:700.0 -- i=3
存钱线程-- 存钱 -- 执行完毕 -- i=3
存钱线程 开始要执行wait操作 -- i=4
取钱线程 执行了wait操作 执行了wait操作 -- i=3
取钱线程 取钱：700.0 -- i=4
取钱线程-- 取钱 -- 执行完毕 -- i=4
取钱线程 开始要执行wait操作 执行了wait操作 -- i=5
存钱线程 执行了wait操作 -- i=4
存钱线程 存款:700.0 -- i=5
存钱线程-- 存钱 -- 执行完毕 -- i=5
取钱线程 执行了wait操作 执行了wait操作 -- i=5
取钱线程 取钱：700.0 -- i=6
取钱线程-- 取钱 -- 执行完毕 -- i=6
取钱线程 开始要执行wait操作 执行了wait操作 -- i=7
存钱线程 存款:700.0 -- i=6
存钱线程-- 存钱 -- 执行完毕 -- i=6
取钱线程 执行了wait操作 执行了wait操作 -- i=7
取钱线程 取钱：700.0 -- i=8
取钱线程-- 取钱 -- 执行完毕 -- i=8
取钱线程 开始要执行wait操作 执行了wait操作 -- i=9
存钱线程 存款:700.0 -- i=7
存钱线程-- 存钱 -- 执行完毕 -- i=7
存钱线程 开始要执行wait操作 -- i=8
取钱线程 执行了wait操作 执行了wait操作 -- i=9
      1.wait()方法执行后，当前线程立即进入到等待阻塞状态，其后面的代码不会执行；
     2.notify()/notifyAll()方法执行后，将唤醒此同步锁对象上的（任意一个-notify()/所有-notifyAll()）线程对象，但是，此时还并没有释放同步锁对象，也就是说，如果notify()/notifyAll()后面还有代码，还会继续进行，直到当前线程执行完毕才会释放同步锁对象；
     3.notify()/notifyAll()执行后，如果右面有sleep()方法，则会使当前线程进入到阻塞状态，但是同步对象锁没有释放，依然自己保留，那么一定时候后还是会继续执行此线程，接下来同2；
     4.wait()/notify()/nitifyAll()完成线程间的通信或协作都是基于不同对象锁的，因此，如果是不同的同步对象锁将失去意义，同时，同步对象锁最好是与共享资源对象保持一一对应关系；
     5.当wait线程唤醒后并执行时，是接着上次执行到的wait()方法代码后面继续往下执行的。

xiangcsdn
关注
专栏目录
Java基础--多线程
weixin_33407107的博客
05-26 75
什么是线程 进程的概念 进程是指可执行程序并存放在计算机存储器的一个指令序列，他是一个动态执行的过程 线程是比进程还要小的运行单位，一个进程包含多个线程 通过对cpu的轮转，来实现系统的多进程。一个软件用1ms cpu轮流使用 什么是多线程 线程的创建 创建一个Thread类，或者一个Thread子类的对象 创建一个实现Runnable接口类的对象 Thread类 是一个线程类，在java.lang包下 Thread类的常用方法 class myThread extends.
Java基础---多线程
热门推荐
我是太阳
01-28 2万+
1、程序、进程、线程 2、线程的创建和使用 3、线程的生命周期 4、线程的同步 例题：模拟火车站售票程序，开启三个售票窗口 public class Ticket implements Runnable { private int tick = 100; @Override public void run() { ...
csdn_多线程
08-12
多线程知识的介绍和使用。让我们更加全面的了解什么是多线程，以及如何使用多线程。
多线程
DHY_41sxn的博客
09-15 294
◆程序 程序就是一段静态的代码，他是程序执行的蓝本。   ◆进程 进程本质是程序的一次动态执行。   进程的特点: 1.动态性。 2.并发性。 3.独立性。   ◆线程 进程内部的一个执行单元。也可称为子进程。   说明:线程也可以理解为程序的一条执行路径。前面所有案例（除了GUI中，他们有内建的多线程支持）都是单线程。任何程序都是从main方法开始往下执行，只会有一条
多线程编程
最新发布
weixin_64193234的博客
07-20 1495
java多线程知识点
python 多线程，CSDN Python 学习班，整理自微信文字课程
kaliopensourcextu
02-28 848
Python作为一门优秀的编程语言，在TIOBE排行榜上，长期稳坐前十的位置。但在日常生活中，尤其是对编程小白来说，想学习一门新语言并不简单，有的甚至只能自学到一点皮毛。 为此，CSDN特向广大Python爱好者开设了学习班，帮助大家在学习Python的道路上少走弯路，事半功倍。上周五，“CSDN博客专家会客厅”走进班级，CSDN博客专家、技术达人刘冬作为受邀专家与大家畅聊Python。 我也
大学课程讲义-Java基础-多线程.pptx
08-14
Java多线程编程基础 本章节主要讲解了Java多线程编程的基础知识，包括线程的概念模型、线程的创建和启动、临界资源、对象锁、线程的互斥和同步等内容。 一、线程的概念模型 在Java中，线程是程序中单个顺序的流...
java课件-5-多线程
01-10
总之，Java多线程编程是一个深度和广度都非常大的主题，涵盖了从基础的线程创建到复杂的并发控制策略，理解并熟练掌握这些知识对于编写高效、可靠的并发Java应用程序具有决定性的影响。通过学习提供的课件和实战练习...
JAVA-多线程 所有文件
01-09
在Java编程语言中，多线程是程序设计中的一个重要概念，尤其在开发高效能和响应迅速的应用时。这个“JAVA-多线程 所有文件”压缩包很可能包含了一系列关于Java多线程学习的源代码示例和相关文档。下面我们将深入探讨...
Java程序基础-多线程概述.pptx
09-15
Java程序基础中的多线程是Java编程中一个重要的概念，特别是在构建高效并发应用程序时不可或缺。在Java中，多线程允许程序同时执行多个任务，从而提高计算机系统的利用率和响应速度。 1. **线程与进程**： - **...
零基础Java入门课程-多线程
07-01
在IT行业中，Java是一种广泛应用的编程语言，尤其在企业级...文档"零基础Java入门课程-多线程-20201217202008101.docx"很可能是课程的详细讲义或笔记，包含了上述知识点的详细解释和实例，建议仔细研读，以加深理解。
Java基础：进程与线程详解-多线程并发实践
进程和线程是计算机操作系统中的两个核心概念，对于Java程序员而言，理解和掌握它们是基础中的基石。本文将深入解析这两个概念，并通过实际的Java编程示例来说明它们的应用。 **进程**： 进程是操作系统中一个正在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值