Java-day19（多线程、线程间的通信）

最新推荐文章于 2022-12-06 20:47:43 发布
最新推荐文章于 2022-12-06 20:47:43 发布
阅读量292 收藏 2
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44742328/article/details/108798637
版权

线程的生命周期

在这里插入图片描述
在这里插入图片描述

线程的同步:

引入问题：
在这里插入图片描述

package com.acoffee.java;

/**
 * 例子：创建三个窗口买票，总票数为100张
 * @author acoffee
 * @create 2020-09-24 20:35
 */

/**
 * @author acoffee
 * @create 2020-09-24 21:25
 */
public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }

}
class Window1 implements Runnable{
    private int ticket = 100;//这里不用加static因为这里只创建了一个window对象

    @Override
    public void run() {
        while (true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName()+":"+ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}


public void run() {
        while (true){
            if(ticket > 0){
        		try{//我们在这里加阻塞条件
        			Thread.sleep(100);
        		}catch(InterruptedException e){
					e.printStackTrace();
				}
                System.out.println(Thread.currentThread().getName()+":"+ticket);
                ticket--;
            }else{
                break;
            }
        }
    }

我们在这段代码中加一个阻塞条件，使线程安全问题更加直观
在这里插入图片描述
它出现了-1就说明存在问题，即：
在这里插入图片描述
在这里插入图片描述
出现问题的原因：当某个线程操作车票（共享数据）的过程中，尚未操作完成，其他线程也进来操作车票。

三个线程在最后run方法中的if语句中的判断条件后 都被阻塞 然后三个线程都进入了if语句 从而造成了上述错票、重票的结果，即线程安全问题。

如何解决：当一个线程A在操作ticket的时候，其他线程不能参与进来，知道线程A操作完ticket时，其他线程才可以操作ticket。这种情况即使线程A出现了阻塞，也不能被改变。

在Java中，我们通过同步机制，来解决线程的安全问题。

共享数据：多个线程共同操作的变量

synchronize的使用方法
在这里插入图片描述

方式一：同步代码块

synchronized(同步监视器){
		需要同步的代码（操作共享数据的代码）
}

说明：

  • 操作共享数据的代码，即为需要被同步的代码。
  • 同步监视器：俗称，锁，任何一个对象都可以成为锁。
  • 要求：多个线程必须要共用同一把锁。

补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。(不是一定具体问题具体分析，比如下述的继承方法中的情况).

说明：在继承Thread类创建多线程的方式中，慎用this充当同步监视器，可以考虑当前类充当同步监视器。

不管用谁必须保证它是唯一的即可，多个线程使用唯一的对象

注意：使用synchronized去包代码块时，不能包多了，也不能包少了（下面的代码你如果把while(true) 也包进去的话就成了单线程了，直接会一个窗口打印完才会解锁）

/**
 * @author acoffee
 * @create 2020-09-24 21:25
 */
public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }

}
class Window1 implements Runnable{
    private int ticket = 100;//这里不用加static因为这里只创建了一个window对象
	Object obj = new Object();

    @Override
    public void run() {
        while (true){
       		//synchronized(this){ 也是正确的，只代表w
			synchronized(obj){
				if(ticket > 0){
        			try{//我们在这里加阻塞条件
        				Thread.sleep(100);
        			}catch(InterruptedException e){
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+":"+ticket);
					ticket--;
            }else{
                break;
				}
			}
		}
	}
}

执行结果：
在这里插入图片描述
如果我们将Object obj = new Object();放在run方法中的话就不能实现同步，因为上个线程都实现了run方法，就创建了三把锁，跟不创建锁是一样的。
在这里插入图片描述
使用同步代码块解决继承Thread类的方式的线程安全问题

/**
 * 使用同步代码块解决继承Thread类的方式的线程安全问题
 * @author acoffee
 * @create 2020-09-25 18:35
 */

class window extends Thread{

    private static int ticket = 100;
    private static Object obj = new Object();

    @Override
    public void run() {
        while (true){
        	//synchronized(this){ 错误的方式：this代表t1,t2,t3三个对象
        	//synchronized(window.class){//也是正确的，其实类也是对象
        	//相当于Class c1 = window.class window.class只会加载一次
            synchronized (obj) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (ticket > 0) {
                    System.out.println(getName() + ":卖票，票号为:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        window w1 = new window();
        window w2 = new window();
        window w3 = new window();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

方式二：同步方法
如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的。

使用同步方法解决时限Runnable接口的线程安全问题

/**
 * 使用同步方法解决时限Runnable接口的线程安全问题
 * @author acoffee
 * @create 2020-09-25 19:14
 */
public class WindowTest2 {
    public static void main(String[] args) {
        Window2 w = new Window2();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }

}
class Window2 implements Runnable{
    private int ticket = 100;

    @Override
    public void run() {
        while (true){
            show();
        }
    }

    public synchronized void show(){//同步监视器：this
        if(ticket > 0){
            try{//我们在这里加阻塞条件
                Thread.sleep(100);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+ticket);
            ticket--;
        }
    }
}

方式三：Lock锁

import java.util.concurrent.locks.ReentrantLock;

/**
 * 解决线程安全问题的方式三：Lock锁 → JDK5.0新增
 * @author acoffee
 * @create 2020-09-26 10:40
 */
class Window implements Runnable{

    private int ticket = 100;
    //实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock(true);

    @Override
    public void run() {
        while (true){
            try {
                //2.调用锁定方式lock()
                lock.lock();
                if(ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":售票：票号为："+ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.调用解锁方式：unlock()
                lock.unlock();
            }

        }
    }
}

public class LockTest {
    public static void main(String[] args) {
        Window w1 = new Window();

        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        Thread t3 = new Thread(w1);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

使用同步方法来解决继承Thread类的线程安全问题

/**
 * 使用同步方法来解决继承Thread类的线程安全问题
 *
 * @author acoffee
 * @create 2020-09-25 19:27
 */
class window3 extends Thread {

    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }

    public static synchronized void show() {//同步监视器：window3.class
    //public synchronized void show(){ 同步监视器：w1，w2,w3
        if (ticket > 0) {
            try {//我们在这里加阻塞条件
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":卖票，票号为:" + ticket);
            ticket--;
        }
    }
}


public class WindowTest3 {
    public static void main(String[] args) {
        window3 w1 = new window3();
        window3 w2 = new window3();
        window3 w3 = new window3();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }

总结：

  • 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
  • 非静态的同步方法，同步监视器是：this
  • 静态方法的同步方法，同步监视器：当前类的本身
  • 解决继承Thread类的情况是使用Lock锁也要用static声明锁，保证使用的是同一把锁

面试题：synchronized 和 Lock 的异同？
相同：二者都可以解决线程的安全问题
不同：

  • synchronized机制在执行完相应的同步代码之后，自动的释放同步监视器
  • Lock需要手动的启动同步（ lock( ) ），同时结束同步也需要手动的实现（unlock( )）
    在这里插入图片描述
    面试题：如何解决线程安全问题？有几种方式？
  • 方式一：同步代码块
  • 方式二：同步方法
  • 方式三：Lock锁

改进单例模式中懒汉式的线程安全问题

懒汉式：

/**
 * @author acoffee
 * @create 2020-09-26 9:18
 */
public class BankTest {
    public static void main(String[] args) {
        Bank b1 = Bank.getInstance();
    }
}
class Bank {
    private Bank() {
    }

    private static Bank instance = null;

        public static synchronized Bank getInstance(){
            if (instance == null){
                instance = new Bank();
            }
            return instance;
        }
}

改进后：方式一（效率较低）：

/**
 * @author acoffee
 * @create 2020-09-26 9:18
 */
public class BankTest {
    public static void main(String[] args) {
        Bank b1 = Bank.getInstance();
    }
}
class Bank {
    private Bank() {
    }

    private static Bank instance = null;
    public static Bank getInstance(){
//    方式一：效率稍差，多线程时对象被建立但是
//    剩余线程还是会进入循环
        synchronized (Bank.class){
            if (instance == null){
                instance = new Bank();
            }
        }
        return instance;
    }
}

方式二(改进后)：效率更高

/**
 * @author acoffee
 * @create 2020-09-26 9:18
 */
public class BankTest {
    public static void main(String[] args) {
        Bank b1 = Bank.getInstance();
    }
}
class Bank {
    private Bank() {
    }

    private static Bank instance = null;
    //方式二(改进后)：效率更高
    public static Bank getInstance() {
        if (instance == null) {
            synchronized (Bank.class) {
                if (instance == null) {
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

死锁：

在这里插入图片描述

/**
 * @author acoffee
 * @create 2020-09-26 10:13
 */
public class DeadLockTest {
    public static void main(String[] args) {
        final StringBuffer s1 = new StringBuffer();
        final StringBuffer s2 = new StringBuffer();
        new Thread(){
            public void run(){
                synchronized (s1){
                    s2.append("a");
                    try {//增加死锁的概率
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2){
                        s2.append("b");
                        System.out.println(s1);
                        System.out.println(s2);
                    }

                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                synchronized (s2){
                    s2.append("c");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1){
                        s1.append("d");
                        System.out.println(s2);
                        System.out.println(s1);
                    }
                }
            }
        }.start();
    }
}

同步机制的练习题

在这里插入图片描述

/**
 * 银行有一个账户
 * 有两个储户分别向同一个账户存3000元，每次存1000，存3次
 * 每次存完打 印账户余额
 *
 * 分析：
 * 1.是否是多线程问题？是，有两个储户线程
 * 2.是否有共享数据？有，账户（或账户余额）
 * 3.是否有线程安全问题？有
 * 4.需要考虑如何解决线程安全问题？同步机制：有三种方式
 *
 * @author acoffee
 * @create 2020-09-26 11:38
 */

class Account{

    private int balance;

    public Account(int balance) {
        this.balance = balance;
    }

    //存钱
    public synchronized void deposit(double amt){//使用synchronized方法来处理线程安全问题
        if (amt > 0){
            balance += amt;

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+":存钱成功，余额为："+balance);
        }
    }
}
class Customer extends Thread{
    private Account acct;

    public Customer(Account acct){
        this.acct = acct;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            acct.deposit(1000);
        }
    }
}

public class AccountTest {
    public static void main(String[] args) {
        Account acct = new Account(0);
        Customer c1 = new Customer(acct);
        Customer c2 = new Customer(acct);

        c1.setName("甲");
        c2.setName("乙");

        c1.start();
        c2.start();
    }
}

线程间的通信

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

涉及到的三个方法：

  • wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
  • notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程 就会唤醒优先级较高的那个。
  • notifyAll():一旦执行此方法，就会唤醒所有被wait的一个线程。
    说明：
  • 1.wait(),notify(),notifyAll()三个方法必须使用在同步代码块 或同步方法中
  • 2.wait(),notify(),notifyAll()三个方法的调用者必须是同步代码块 或 同步方法中的同步监视器，否则，会出现 IllegalMonitorStateException异常
  • 3.wait(),notify(),notifyAll()三个方法是定义在 java.lang.Object类中的.这也与任何对象都可以充当同步监视器印和，因为是同步监视器去调用它，而同步监视器是任何对象都可以充当的，只有当这三个对象是object类中的，任何对象才是可以 调用的，所以与其印和。
/**
 * 线程通信的例子：使用两个线程打印 1-100.线程1，线程2, 交替打印
 *
 * @author acoffee
 * @create 2020-09-26 15:50
 */
public class CommunicationTest {

    public static void main(String[] args) {

        Number n1 = new Number();

        Thread t1 = new Thread(n1);
        Thread t2 = new Thread(n1);

        t1.setName("窗口1");
        t2.setName("窗口2");

        t1.start();
        t2.start();
    }
}

class Number implements Runnable{
    private int number = 1;

    @Override
    public void run() {
        while (true){
            synchronized (this){

                notify();//this调用的

                if(number <= 100){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number++;

                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }else{
                    break;
                    }
                }
            }
        }
    }

面试题：sleep( ) 方法和 wait( ) 方法的异同？

  • 相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态
  • 不同点：
    1.两个个方法声明的位置不同：Thread类中的声明sleep()，Object类中声明wait( )
    2.调用的要求不同：sleep( ) 可以在任何需要的场景下调用。wait( ) 必须使用在同步代码块 或同步方法中
    3.关于是否释放同步监视器，如果两个方法都是用在同步代码块或同步方法中，sleep( )不会释放锁，wait( )会释放锁

从执行时间上也可以获得sleep( )不会释放锁，wait( )会释放锁的结论

public class threadTest {
    static final Object Lock = new Object();

    @Test
    public void waiting() throws InterruptedException {
        Thread t1 = new Thread(()->{
           synchronized (Lock){
               try {
                   System.out.println("waiting~~");
                   Lock.wait();

               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        },"t1");
        long start = System.currentTimeMillis();
        t1.start();

        Thread.sleep(100);
        synchronized (Lock){
            System.out.println("other~~");
        }
        long end = System.currentTimeMillis();
        System.out.println("执行时间："+(end-start));//执行时间：102
    }
    @Test
    public void sleeping() throws InterruptedException {
        Thread t2 = new Thread(()->{
           synchronized (Lock){
               try {
                   System.out.println("sleeping~~");
                   Thread.sleep(5000);

               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        },"t2");
        long start = System.currentTimeMillis();
        t2.start();

        Thread.sleep(100);
        synchronized (Lock){
            System.out.println("other~~");
        }
        long end = System.currentTimeMillis();
        System.out.println("执行时间："+(end-start));//执行时间：5002
    }
}

线程通信：生产者消费者模式

在这里插入图片描述

/**
 * 线程通信的应用：经典例题：生产者/消费者问题
 *
 * 分析：
 * 1.是否是多线程问题？是，生产者线程，消费者线程
 * 2.是否有共享数据？是，店员（或产品）
 * 3.如何解决线程的安全问题？同步机制，有三种方法
 * 4.是否涉及线程的通信？是
 *
 * @author acoffee
 * @create 2020-09-26 16:41
 */

class Clerk{

    Object obj = new Object();
    private int productNumber;

    public synchronized void ProduceProduct(){


            if(productNumber < 20){
                productNumber++;
                System.out.println(Thread.currentThread().getName()+"生产的，第"+productNumber+"个产品");
                notify();
            }else{
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }


    //消费产品
    public synchronized void consumeProduct(){

            if (productNumber > 0){
                System.out.println(Thread.currentThread().getName()+"消费的，第"+productNumber+"个产品");
                productNumber--;
                notify();
            }else{
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }


class Producer extends Thread {//生产者
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        while (true) {

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getName() + ":开始生产产品...");
            clerk.ProduceProduct();
        }
    }
}
class Consumer extends Thread{//消费者
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }
    @Override
    public void run() {
        while (true){

            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        System.out.println(getName()+":开始消费产品...");
        clerk.consumeProduct();
        }
    }
}

public class ProdutTest {
    public static void main(String[] args) {

        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        Consumer c1 = new Consumer(clerk);

        p1.setName("生产者1");
        c1.setName("消费者1");

        p1.start();
        c1.start();
    }
}

JDK5.0新增线程创建方式

新增方式一：实现Callable接口
在这里插入图片描述
在这里插入图片描述

package com.acoffee.java;

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

/**
 * 创建线程的方式三：实现Callable接口。 --- JDK 5.0新增
 * @author acoffee
 * @create 2020-09-26 18:51
 */

//1.创建一个实现Callable的实现类
    class NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }

}

public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将次Callable接口实现类的对象作为参数传递到
        //FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类
        // 的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            Object sum = futureTask.get();
            System.out.println("总和为："+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

执行结果：
在这里插入图片描述

新增方式二：使用线程池
在这里插入图片描述

package com.acoffee.java;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author acoffee
 * @create 2020-09-26 19:19
 */
public class ThreadPool {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适用于Runnable
        service.execute(new NumberThread1());//适用于Runnable
        //service.submit(Callable callable);适用于Callable

        //关闭线程池
        service.shutdown();
    }
}
class NumberThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
class NumberThread1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

面试题：创建多线程有几种方式？四种！

每日一练：

1. 画图说明线程的生命周期，以及各状态切换使用到的方法等
在这里插入图片描述

2. 同步代码块中涉及到同步监视器和共享数据，谈谈你对同步监视器和共享数据的理解，以及注意点。

synchronized(同步监视器){
//操作共享数据的代码 （不能包括多了，也不能包括少了）
}

3. sleep()和wait()的区别

  • 相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态
  • 不同点：
    1.两个个方法声明的位置不同：Thread类中的声明sleep()，Object类中声明wait( )
    2.调用的要求不同：sleep( ) 可以在任何需要的场景下调用。wait( ) 必须使用在同步代码块 或同步方法中
    3.关于是否释放同步监视器，如果两个方法都是用在同步代码块或同步方法中，sleep( )不会释放锁，wait( )会释放锁

4. 写一个线程安全的懒汉式

class bankTest 
{
	public static void main(String[] args) 
	{
		order o1 = order.getInstance();
		order o2 = order.getInstance();

		System.out.println(o1 == o2);
	}
}

class order
{
	public order(){}

	private static order instance = null;

	public static order getInstance(){
		if(instance == null){
		synchronized(order.class){
		if(instance == null){
			instance = new order();
				}
			}
		}
		return instance;
	}
}

5. 创建多线程有哪几种方式：4种
继承Thread类
实现Runnable接口
实现Callable接口
线程池（响应速度提高了，提高了资源的重用率，便于管理）

vid。
关注
专栏目录
Java学习路线：day19
01-20
多线程线程的生命周期线程的同步同步代码块处理实现Runnable的线程安全问题同步代码块处理继承Thread类的线程安全问题同步方法处理实现Runnable的线程安全问题同步方法处理继承Thread类的线程安全问题线程安全的单例...
java线程同步
清风不灭的博客
01-25 471
目录 一、实现Runnable接口的线程同步问题 二、继承Thread类的线程同步问题 三、同步方式优缺点 一、synchronized实现Runnable接口的线程同步问题 方式一：同步代码块 synchronized(同步监视器){ //需要被同步的代码放在此处 } 说明：1、操作共享数据的代码块，即为需要被同步的代码。 2、共享数据（临界...
JavaSE多线程-线程的安全问题以及解决线程安全问题的两种方式
qq_46112274的博客
06-07 149
线程
java多线程
ALi的博客
04-20 327
一、基本概念：程序、进程、线程 进程可以细化为多个线程。 每个线程，拥有自己独立的：栈、程序计数器 多个线程，共享一个进程中的结构：方法区和堆。 程序：为完成特定任务、用某种语言编写的一组指令的集合。即一段静态的代码，静态对象。 进程：是程序的一次执行过程，或者是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在、消亡的过程。 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。 线程：进程可以进一步细化为线程，是一个程序内部的一条执行路径。与进程不同的是同类的多个线程共享进
Java 多线程三：线程同步和通信
最新发布
qq_48010634的博客
12-06 289
Java 多线程三：线程同步和通信
Java高级编程之多线程
weixin_44508223的博客
06-16 245
Java编程之多线程 补充： Eclipse每一个workspce都有一个.metaspace，包含该工作空间的一些配置。 而IntelliJIDEA则有一个统一的config文件夹 Eclipse中的workspace相当于IDEA中的project Eclipse中的project相当于IDEA中的Module 关于idea安装： 从官网下载.exe文件，然后配置 ...
Java_day19上课资料.zip
04-01
"Java_day19上课资料.zip"这个压缩包文件很可能是某个教学课程的第19天的学习资源，包含了深入学习Java的关键知识点。配合提供的视频链接（），我们可以期待获得更丰富的视听学习体验。 在Java的学习过程中，第19天...
Java_day09上课资料.zip
03-24
5. **多线程**：Java提供了丰富的多线程支持。这一天可能会讲解线程的创建方式（Thread类和Runnable接口），线程同步（synchronized关键字，wait()和notify()方法），以及线程池的使用。 6. **反射**：反射是Java的...
day19_阻塞队列、线程池、File类、递归.pdf
11-02
阻塞队列是并发编程中的一种重要工具，它在多线程环境下的生产者-消费者模型中起到关键作用。线程池则是为了优化线程管理，提高系统效率而设计的。File类则用于处理文件和目录的操作，而递归是一种解决问题的方法，...
Wiley.-.Java.in.60.Minutes.a.Day.(19.Lectures,.789.pages).rar
01-19
12. **Java库与API**：探讨Java标准库，如IO、NIO、集合、多线程、网络编程等API的使用。 13. **JavaFX与Swing**：虽然现在JavaFX不再包含在标准JDK中，但它们是构建桌面图形用户界面的重要工具，可以创建丰富的...
Java高级--多线程
qq_43803371的博客
07-21 188
线程的常用方法 start():启动当前线程，调用当前线程的run()。 run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中。 currentThread():静态方法，返回执行当前代码的线程。 getName():获取当前线程的名字。 setName():设置当前线程的名字。 yield():释放当前cpu执行权。 join():在线程A中调用线程B的join(),此时线程a进入阻塞状态，直到线程b完全执行后，线程a才结束阻塞状态。 stop():已过
java多线程实现Runnable接口的线程安全问题
weixin_46122692的博客
11-16 1154
一、案例：模拟火车站售票，开启三个窗口售票 出现的问题：卖票过程中，出现了重票、错票 ==>也就是出现了线程的安全问题 问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。 解决思路：当一个线程(一个窗口)在操作ticket(火车票)的时候，其他线程不能参与进来。直到这个线程(这个窗口)操作完ticket(火车票)时，其他线程才可以开始操作ticket(火车票)。这种情况即使这个线程(这个窗口)出现了阻塞，也不能被改变。 解决办法：在Java中，我们通过同步机制
解决线程安全问题的两种方法
weixin_44804405的博客
07-25 287
在java中，我们采用同步机制，来解决线程安全问题 *方式一： 同步代码块 synchronized同步监视器(){ //需要同步的代码 } 说明： 1.操作共享数据的代码，即为需要被同步的代码，–》不能包含代码多了，也不能包含代码少了 2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据 3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁 要求：多个线程必须共用一把锁 补充：在实现Runnable接口创建线程的方式中，我们可以考虑使用this充当同步监视器 方式二 同步方法 如果操
JavaSE笔记-------第八章 多线程
weixin_45226558的博客
07-29 187
.基本概念：程序、进程、线程 多线程的优点： 1.提高应用程序的相应 2.提高计算机系统CPU的利用率 3.改善程序结构 创建多线程方式一：继承Thread类 1.创建一个继承于Thread类的子类 2.重写Thread类的run()方法---->将此线程执行的操作声明在run()中 3.创建Thread类的子类的对象 4.通过此对象调用start()方法 作用：①启动当前线程 ②调用当前线程的run()犯法 问题一：我们不能通过直接调用run()的方法启动
Java高级语法（一）：多线程
weixin_44800710的博客
11-21 524
1.基本概念：程序、进程、线程 2.线程的创建和使用 1.多线程的创建： 1.方式一：继承于Thread类 1.创建一个继承于Thread类的子类 2.重写Thread类的run() →将此线程执行的操作声明在run()中 3.创建Thread类的子类的对象 ...
解决线程安全问题的方法
weixin_71644439的博客
06-20 598
多线程
Java高级-多线程编程
Achilles的博客
09-13 203
多线程的创建，方式一：继承于Thread类 1. 创建一个继承于Thread类的子类 2. 重写Thread类的run() -->将此线程执行的操作声明在run()中 3. 创建Thread类的子类的对象 4. 通过此对象调用start() 例子：遍历100以内的所有的偶数 // 1. 创建一个继承于Thread类的子类 class MyThread extends Thread { // 2. 重写Thread类的run() @Override public voi.
Java学习19天 线程安全同步方法 创建线程方法
weixin_45875998的博客
08-15 185
线程安全的同步 线程生命周期（需要掌握） 1.问题:卖票过程中，出现了重票、错票（0，-1。。。）–>出现了线程的安全问题 2.问题出现的原因:当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票（共享数据） 3.如何解决:当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。 在Java中，我们通过同步机制，来解决线程的安全问题。 方式一:同步代码块 说明:
JAVA之多线程
qq_41906909的博客
06-07 191
一、程序、进程、线程 1. 程序(program) 概念：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。 2. 进程(process) 概念：程序的一次执行过程，或是正在运行的一个程序。 说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 3. 线程(thread) 概念：进程可进一步细化为线程，是一个程序内部的一条执行路径。 说明：线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小。 内存结构： 进
Java多线程实现线程安全单例模式解析
"本文主要探讨了Java多线程环境下的线程安全单例模式，包括其概念、特点以及两种常见的实现方式：懒汉式和饿汉式。" 在Java编程中，单例模式是一种常用的设计模式，其核心目标是确保一个类在整个应用程序中只有一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值