JUC

最新推荐文章于 2023-06-12 02:26:55 发布
最新推荐文章于 2023-06-12 02:26:55 发布
阅读量155 收藏
点赞数 1
分类专栏： Java基础 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lin_willen/article/details/103025432
版权

目录

一、什么是JUC

二、Lock接口

1、多线程编程模板（上）

2、实现步骤

3、例子卖票程序

三、lambda表达式

四、线程不安全

1、分析线程不安全从哪几个方面入手？

2、ArrayList线程不安全代码

解决方法：

重点——写时复制

3、HastSet线程不安全代码

解决方法：

4、HastSet线程不安全代码

解决方法：

五、八锁

六、生产者消费者（虚假唤醒问题）

1、多线程编程模板（中）

2、传统方法：

3、Lock方法

4、案例

七、Callable接口

​

一、什么是JUC

1、JUC（java.util.concurrent）是在并发编程中使用的工具类

2、进程、线程是什么

        进程：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。
        线程：通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程可以利用进程所拥有的资源，在引入线程的操作系统中，通常都是把进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位，由于线程比进程更小，基本上不拥有系统资源，故对它的调度所付出的开销就会小得多，能更高效的提高系统多个程序间并发执行的程度。

3、进程、线程的例子

  • 使用QQ，查看进程一定有一个QQ.exe的进程，我可以用qq和A文字聊天，和B视频聊天，给C传文件，给D发一段语言，QQ支持录入信息的搜索。

  • 大四的时候写论文，用word写论文，同时用QQ音乐放音乐，同时用QQ聊天，多个进程。

  • word如没有保存，停电关机，再通电后打开word可以恢复之前未保存的文档，word也会检查你的拼写，两个线程：容灾备份，语法检查

4、线程的状态（粗分5种，细分6种）

Thread.State
 
 
public enum State {
    /**
     * Thread state for a thread which has not yet started.
     */
    NEW,(新建)

    /**
     * Thread state for a runnable thread.  A thread in the runnable
     * state is executing in the Java virtual machine but it may
     * be waiting for other resources from the operating system
     * such as processor.
     */
    RUNNABLE,（准备就绪）

    /**
     * Thread state for a thread blocked waiting for a monitor lock.
     * A thread in the blocked state is waiting for a monitor lock
     * to enter a synchronized block/method or
     * reenter a synchronized block/method after calling
     * {@link Object#wait() Object.wait}.
     */
    BLOCKED,（阻塞）

    /**
     * Thread state for a waiting thread.
     * A thread is in the waiting state due to calling one of the
     * following methods:
     * <ul>
     *   <li>{@link Object#wait() Object.wait} with no timeout</li>
     *   <li>{@link #join() Thread.join} with no timeout</li>
     *   <li>{@link LockSupport#park() LockSupport.park}</li>
     * </ul>
     *
     * <p>A thread in the waiting state is waiting for another thread to
     * perform a particular action.
     *
     * For example, a thread that has called <tt>Object.wait()</tt>
     * on an object is waiting for another thread to call
     * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
     * that object. A thread that has called <tt>Thread.join()</tt>
     * is waiting for a specified thread to terminate.
     */
    WAITING,（不见不散）

    /**
     * Thread state for a waiting thread with a specified waiting time.
     * A thread is in the timed waiting state due to calling one of
     * the following methods with a specified positive waiting time:
     * <ul>
     *   <li>{@link #sleep Thread.sleep}</li>
     *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
     *   <li>{@link #join(long) Thread.join} with timeout</li>
     *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
     *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
     * </ul>
     */
    TIMED_WAITING,（过时不候）

    /**
     * Thread state for a terminated thread.
     * The thread has completed execution.
     */
    TERMINATED;(终结)
}

5、wait和sleep的区别

功能都是当前线程暂停，wait放开手去睡 ，放开手里的锁，sleep握紧手去睡，醒了手里还有锁

6、什么是并发？什么是并行？

并发：同一时刻多个线程在访问同一个资源，多个线程对一个点
      例子：小米9今天上午10点，限量抢购
            春运抢票
            电商秒杀...
并行：多项工作一起执行，之后再汇总
      例子：泡方便面，电水壶烧水，一边撕调料倒入桶中

二、Lock接口

1、多线程编程模板（上）

在高内聚低耦合的前提下，线程  操作  资源类

2、实现步骤

1）创建资源类

2）资源类里创建同步方法、同步代码块

3、例子卖票程序

class Ticket{
   private int number = 30;
   Lock lock = new ReentrantLock();
   public void sale(){
       lock.lock();
       try {
           if (number>0){
               System.out.println(Thread.currentThread().getName()+"卖出"+(number--)+"\t 还剩"+number);
           }
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           lock.unlock();
       }
   }
}
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        //Thread thread = new Thread();
        Ticket ticket = new Ticket();
        //Runnable是接口，接口是特殊的类，所以接口可以new，new出来的叫匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {开发不用while(true)
                    ticket.sale();
                }
            }
        },"A").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.sale();
                }
            }
        },"B").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.sale();
                }
            }
        },"C").start();
        //以上代码可用lambda表达式代替
        //new Thread(() ->{for (int i = 0; i < 40; i++)ticket.sale();},"A").start();
        //new Thread(() ->{for (int i = 0; i < 40; i++)ticket.sale();},"B").start();
        //new Thread(() ->{for (int i = 0; i < 40; i++)ticket.sale();},"C").start();
    }
}

三、lambda表达式

1、写法：

1）拷贝小括号（），写死右箭头->，落地大括号{...}

2）@FunctionalInterface：声明函数式接口

3）default

4）static

注意：lambda表达式，如果一个接口只有一个方法，可以把方法名省略

 

//不写默认加@FunctionalInterface,此注解规定接口中只能有一个方法
interface Foo{
    //void say();
    int add(int x,int y);
    //JDK1.8允许在接口中声明默认方法，加上此方法编译也是能通过的
    public default int mul(int x,int y){
        return x*y;
    }
    //并且默认方法可以有多个
    default int mul2(int x,int y){
        return x*y;
    }
    //1.8允许在接口中声明静态方法，也可以声明多个
    static int div(int x,int y){
        return x/y;
    }
    static int div2(int x,int y){
        return x/y;
    }
}
public class LambdaExpressDemo02 {
    public static void main(String[] args) {
        Foo foo = (int x,int y) -> {
            System.out.println("add方法");
            return x+y;
        };
        System.out.println(foo.add(3,4));
        System.out.println(foo.mul(3, 5));
        //用接口名调用
        System.out.println(Foo.div(5, 2));
    }
}

四、线程不安全

1、分析线程不安全从哪几个方面入手？

1）故障原因

java.util.ConcurrentModificationException

2）导致原因

3）解决方法

4）优化建议（同样的错误不放第2次）

2、ArrayList线程不安全代码

public class NotSafeDemo03 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
//        list.forEach(System.out::println);
        for(int i = 1;i <= 30; i++){
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0,8));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

解决方法：

List<String> list = new ArrayList<>();
//修改为
List<String> list = new Vector<>();
List<String> list = Collections.synchronizedList(new ArrayList<>());
List<String> list = new CopyOnWriteArrayList();

重点——写时复制

/*CopyOnWrite容器即写时复制的容器，往一个容器添加元素的时候，不直接往当前容器Object[]添加，
而是先将当前容器Object[]进行Copy，复制出一个新的容器Object[] newElements，
然后往新的容器Object[] newElements里面添加元素，添加完元素之后再将元容器中的引用指向新的容器setArray(newElements);
这样做的好处是可以对CopyOnWrite容器进行并发的读，而不需要加锁，
因为当前容器不会添加任何元素。所以CopyOnwrite容器也是一种读写分离的思想，读和写不同的容器
*/
public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

3、HastSet线程不安全代码

 public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        for(int i = 1;i <= 30; i++){
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0,8));
                System.out.println(set);
            },String.valueOf(i)).start();
        }

    }

解决方法：

Set<String> set = new CopyOnWriteArraySet<>();//new HashSet<>();

1、HastSet底层是HashMap

//HashSet源码
private static final Object PRESENT = new Object();

public HashSet() {
        map = new HashMap<>();
    }

public boolean add(E e) {
        return map.put(e, PRESENT)==null;
}

4、HastSet线程不安全代码

public static void main(String[] args) {
//        setNotSafe();
        Map<String,String> map = new HashMap<>();
        for(int i = 1;i <= 30; i++){
            new Thread(() -> {
                map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,8));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }

解决方法：

Map<String,String> map = new ConcurrentHashMap<>();//new HashMap<>();

五、八锁

import java.util.concurrent.TimeUnit;

class Phone{
    public  synchronized void sendSMS() throws Exception{
        System.out.println("------sendSMS");
    }
    public synchronized void sendEmail() throws Exception{
        System.out.println("------sendEmail");
    }
    public void getHello() {
        System.out.println("------getHello");
    }
}
 
/**
 * 
 * @Description: 8锁
 * 
 1 标准访问，先打印短信还是邮件
 2 停4秒在短信方法内，先打印短信还是邮件
 3 新增普通的hello方法，是先打短信还是hello
 4 现在有两部手机，先打印短信还是邮件
 5 两个静态同步方法，1部手机，先打印短信还是邮件
 6 两个静态同步方法，2部手机，先打印短信还是邮件
 7 1个静态同步方法,1个普通同步方法，1部手机，先打印短信还是邮件
 8 1个静态同步方法,1个普通同步方法，2部手机，先打印短信还是邮件
 * ---------------------------------
 * 
 */
public class Lock_8{
    public static void main(String[] args) throws Exception{
        Phone phone = new Phone();
        Phone phone2 = new Phone();
   
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
       }, "AA").start();
   
       Thread.sleep(100);
   
       new Thread(() -> {
            try {
                 phone.sendEmail();
                 //phone.getHello();
                 //phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
       }, "BB").start();
    }
}
 
 

// synchronized锁的是当前对象——对象锁，锁this
// static synchronize锁的是整个类——全局锁，锁Class，static修饰的同步方法
* *一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，
其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访间这些synchronized方法，
锁的是当前对象this,被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法
*加个普通方法后发现和同步锁无关
*换成两个对象后，不是同一把锁了，情况立刻变化。
*都换成静态同步方法后， 情况又变化
*所有的非静态同步方法用的都是同一把锁——实例对象本身，

synchronized实现同步的基础: Java中的每一个对象都可以作为锁。
*具体表现为以下3种形式。
*对于普通同步方法，锁是当前实例对象。
*对于同步方法块，锁是Synchonized括号里配置的对象。
*对于静态同步方法，锁是当前类的Class对象。

当一个线程试图访间同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。|
也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，
可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，
所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。

所有的静态同步方法用的也是同一一把锁——类对象本身，
这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。
但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，
而不管是同一个实例对象的静态同步方法之间，
还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象!

六、生产者消费者（虚假唤醒问题）

1、多线程编程模板（中）

1）判断（while）

2）干活

3）通知

4）防止虚假唤醒

2、传统方法：

//资源类
class AirCondition{
    private int number = 0;
    public synchronized void increment()throws Exception{
        //判断
        if(number !=0)
            this.wait();
        //干活
        number++;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        //通知
        this.notifyAll();
    }
    public synchronized void decrement()throws Exception{
        //判断
        if(number ==0)
            this.wait();
        //干活
        number--;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        //通知
        this.notifyAll();
    }
}
public class ProdConsumerDemo04 {
    public static void main(String[] args) {
        AirCondition airCondition = new AirCondition();
        new Thread(() ->{
            for (int i = 1; i <= 10; i++) {
                try {
                    Thread.sleep(200);
                    airCondition.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(() ->{
            for (int i = 1; i <= 10; i++) {
                try {
                    Thread.sleep(300);
                    airCondition.decrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(() ->{
            for (int i = 1; i <= 10; i++) {
                try {
                    Thread.sleep(400);
                    airCondition.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(() ->{
            for (int i = 1; i <= 10; i++) {
                try {
                    Thread.sleep(500);
                    airCondition.decrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

运行结果：

虚假唤醒的原因：判断是用if

3、Lock方法

//资源类
class AirCondition{
    private int number = 0;
    Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    public void increment()throws Exception{
        lock.lock();
        try {
            //判断
            while (number !=0)
                //this.wait();
                condition.await();
            //干活
            number++;
            System.out.println(Thread.currentThread().getName()+"\t"+number);
            //通知
            //this.notifyAll();
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void decrement()throws Exception{
        lock.lock();
        try {
            //判断
            if(number ==0)
                //this.wait();
                condition.await();
            //干活
            number--;
            System.out.println(Thread.currentThread().getName()+"\t"+number);
            //通知
            //this.notifyAll();
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
public class ProdConsumerDemo04 {
    public static void main(String[] args) {
        AirCondition airCondition = new AirCondition();
        new Thread(() ->{
            for (int i = 1; i <= 10; i++) {
                try {
                    Thread.sleep(200);
                    airCondition.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(() ->{
            for (int i = 1; i <= 10; i++) {
                try {
                    Thread.sleep(300);
                    airCondition.decrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(() ->{
            for (int i = 1; i <= 10; i++) {
                try {
                    Thread.sleep(400);
                    airCondition.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(() ->{
            for (int i = 1; i <= 10; i++) {
                try {
                    Thread.sleep(500);
                    airCondition.decrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

4、案例

题目：多线程之间按顺序调用，实现A->B->C

三个线程启动，要求如下

A打印5次，B打印10次，C打印15次

接着，A打印5次，B打印10次，C打印15次

打印10轮

package cn.wyu.juc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class ShareData{
    private int number = 1;
    private Lock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();
    public void print5(){
        lock.lock();
        try {
            //判断，如果是number是2或3就让A等待
            while (number != 1)
                //wait...
                c1.await();
            //干活
            for (int i = 1; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //通知
            number = 2;
            c2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void print10(){
        lock.lock();
        try {
            //判断，让其它线程阻塞
            while (number != 2)
                //wait...
                c2.await();
            //干活
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //通知
            number = 3;
            c3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void print15(){
        lock.lock();
        try {
            //判断，让其它线程阻塞
            while (number != 3)
                //wait...
                c3.await();
            //干活
            for (int i = 1; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //通知
            number = 1;
            c1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
public class ConditionDemo {
    public static void main(String[] args) {
        ShareData shareData = new ShareData();
        new Thread(() ->{
            for (int i = 1; i <= 10; i++) {
                shareData.print5();
            }
        },"A").start();
        new Thread(() ->{
            for (int i = 1; i <= 10; i++) {
                shareData.print10();
            }
        },"B").start();
        new Thread(() ->{
            for (int i = 1; i <= 10; i++) {
                shareData.print15();
            }
        },"C").start();

    }
}

七、Callable接口

package cn.wyu.juc;

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

class Mythread implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        System.out.println("********");
        return 1024;
    }
}
public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> futureTask = new FutureTask(new Mythread());
        new Thread(futureTask,"A").start();
        Integer result = futureTask.get();
        System.out.println(result);
    }
}

 

 

不会Java怎么找女朋友
关注
专栏目录
JUC（三）
qq_43651045的博客
08-07 143
JMM lock unlock read load use assign store write Volatile 1、保证可见性，写操作后插入一个写屏障指令，在读操作前插入一个读屏障指令 2、不保证原子性（可以加锁或者使用原子类） public class VolatileTest { // volatile static int num = 0; static AtomicInteger num = new AtomicInteger(); public static v
JUC并发编程
热门推荐
识时务者的个人博客
07-08 14万+
JUC并发编程 JUC简介 进程、线程的关系 Java默认有两个线程 线程的六种状态 并发、并行的关系： Lock锁 Synchronized 和 Lock的区别 8锁现象 问题一 : 在标准情况下，两个线程先打印 发短信 还是 打电话 ？ 问题二 : 在发短信方法中，延迟4秒，两个线程先打印 发短信 还是 打电话？ 问题三 : Phone类增加一个普通方法，线程B调用，那么两个线程先打印 发短信
JUC详解
weixin_53379153的博客
06-12 1万+
什么是JUC？ JUC其实就是JDK中的三个包: java.util.concurrent 并发相关的 java.util.concurrent.atomic 原子性 java.util.concurrent.locks lock锁 Runnable 没有返回值，效率相比Callable相对较低。 进程：一个程序，QQ，Music.exe 程序的集合 ；一个进程可以包含多个线程，至少包含一个。 Java默认有几个线程？ 2个 main线程和GC线程（做垃圾回收） Java可以开启
根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档
09-21
1、根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档 2、包含源码 视频地址：https://www.bilibili.com/video/BV1ar4y1x727/?p=1&vd_source=c634d163b940964d44747b4c3976117b 参考资料：...
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
狂神说JUC代码狂神说JUC代码
09-11
【狂神说JUC代码】是一系列专注于Java并发编程（JUC，Java Util Concurrency）的教程或笔记，旨在帮助开发者深入理解并掌握Java平台上的并发处理机制。JUC是Java标准库中的一组高级并发工具类，为多线程环境下的程序...
尚硅谷JUC视频笔记整理,很详细和全面，帮你迅速掌握JUC
12-27
JUC（Java Util Concurrent），即Java的并发工具包，是Java提供的一套并发编程解决方案，它通过一系列接口和类简化了并发编程的复杂性。本笔记整理涉及了JUC的内存可见性、volatile关键字以及CAS算法和原子变量等多...
VB+ACCESS网吧计费系统(源代码+系统).zip
09-18
1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。
基于C#的小区物业管理系统.docx
09-18
设计一个基于C#的小区物业管理系统是一个涉及多个方面和模块的复杂项目。这样的系统通常包括用户管理、房屋管理、费用管理、报修管理、投诉管理、公告管理等功能。下面我将简要概述如何构建一个基本的小区物业管理系统，包括其主要模块和一些关键概念。 1. 系统架构设计 前端界面：可以使用WinForms或WPF来构建桌面应用程序界面，也可以使用ASP.NET Core MVC或Blazor来构建Web界面。 后端逻辑：使用C#作为后端开发语言，结合.NET Core或.NET Framework来编写业务逻辑。 数据库：可以使用SQL Server、MySQL或SQLite等数据库来存储系统数据。 架构模式：考虑使用MVC（模型-视图-控制器）或三层架构（表示层、业务逻辑层、数据访问层）来组织代码。 2. 主要功能模块 2.1 用户管理 功能：管理小区业主、租户、物业工作人员等用户的信息。 关键操作：用户注册、登录、密码找回、用户信息编辑、权限管理等。 2.2 房屋管理 功能：管理小区内所有房屋的信息，包括房屋位置、面积、户型、业主信息等。 关键操作：房屋信息录入、查询、修改、删除、房屋状态更新
4-3_Education_BLUE_2017_03-CL-20180524MTAX.potx
09-18
微软演示材料
C#通过COM读取Excel到dataGridView
09-18
C#通过COM读取Excel到dataGridView
4-3_Consumer_BLUE_2017_03.potx
09-18
微软演示材料
4-3_Business_DK_BLUE_2017_03-CL-20180524MTAX.potx
09-18
微软演示材料
【精品毕设推荐】-基于微信小程序的儿童预防接种预约系统设计与实现.zip
09-18
【项目简介】 可辅助在本地配置运行 随着信息技术在管理上越来越深入而广泛的应用，管理信息系统的实施在技术上已逐步成熟。本文介绍了儿童预防接种预约微信小程序的开发全过程。通过分析医院挂号信息管理的不足，创建了一个计算机管理医院挂号信息的方案。文章介绍了儿童预防接种预约微信小程序的系统分析部分，包括可行性分析等，系统设计部分主要介绍了系统功能设计和数据库设计。 本儿童预防接种预约微信小程序可以实现管理员和用户。管理员功能有个人中心，用户管理，儿童信息管理，疫苗信息管理，儿童接种管理，儿童接种史管理，医疗机构管理，预约接种管理，系统管理等。用户功能有注册登录，儿童信息，疫苗信息，儿童接种，儿童接种史，医疗机构，预约接种，我的收藏管理等。因而具有一定的实用性。 本站后台采用Java的SSM框架进行后台管理开发，可以在浏览器上登录进行后台数据方面的管理，MySQL作为本地数据库，微信小程序用到了微信开发者工具，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得医院挂号信息管理工作系统化、规范化。 关键词：儿童预防接种预约微信小程序；SSM框架；MYSQL
【路径规划】用于路径规划的星形算法Matlab实现.rar
最新发布
09-18
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
java基于ssm+jsp 农场信息化管理系统源码 带毕业论文+ppt+sql
09-18
1、开发环境：SSM框架；内含Mysql数据库；jsp技术；内含说明文档 2、项目代码都经过严格调试，代码没有任何bug！ 3、该资源包括项目的全部源码，下载可以直接使用！ 4、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料学习借鉴。 5、本资源作为“参考资料”如果需要实现其他功能，需要能看懂代码，并且热爱钻研，自行调试。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值