黑马程序员—多线程

最新推荐文章于 2024-01-17 09:45:23 发布
最新推荐文章于 2024-01-17 09:45:23 发布
阅读量434 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kuangquanshui517/article/details/9094923
版权
----------------------   JavaEE+Android、Java培训、期待与您交流！ ----------------------


进程

进程是处于运行过程中的程序，并且具有一定独立功能，进程是系统进行资源分配和调度的一个独立单位。一般而言，进程包含独立性，动态性和并发性。并行性是指同一时刻，有多条指令在多个处理器上同时执行；并发性是指同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果。
线程

线程也被称作轻量级进程，线程是进程的执行单元。线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程是共享父进程中的共享变量及部分环境，相互之间协同来完成进程所要完成的任务。
注：在java中，JVM虚拟机启动时，会有一个进程为java.exe，该程序中至少有一个线程负责java程序的执行；而且该程序运行的代码存在于main方法中，该线程称之为主线程。其实，JVM启动时不止有一个线程（主线程），由于java是具有垃圾回收机制的，所以，在进程中，还有负责垃圾回收机制的线程。

线程的创建和启动
创建新执行线程有两种方法：

一种是继承Thread类创建线程类；另一种是实现Runnable接口创建线程类。

继承Thread类步骤：

a、定义类继承Thread。

b、复写Thread类中的run方法（run方法里存放的是线程运行的代码，因为Thread中的run方法原本是空的方法，所以要被复写）。

c、调用线程的start方法（start方法：启动线程，并调用run方法，如果直接调用run方法，仅仅是对象调用方法，线程并没有运行）。

<span style="font-family: Arial; ">class Demo extends Thread
{
	public void run()
	{
		for (int i=0;i<60;i++)
			System.out.println(Thread.currentThread().getName() + "demo run---" + i);
	}
}
class Test2
{
	public static void main(String[] args) 
	{
		Demo d1 = new Demo();//创建一个对象就创建好了一个线程
		Demo d2 = new Demo();
		d1.start();//开启线程并执行run方法
		d2.start();
		for (int i=0;i<60;i++)
			System.out.println("Hello World!---" + i);
	}
}</span>






运行特点：




A.并发性：我们看到的程序（或线程）并发执行，其实是一种假象。有一点需要明确：；在某一时刻，只有一个程序在运行（多核除外），此时cpu是在进行快速的切换，以达到看上去是同时运行的效果。由于切换时间是非常短的，所以我们可以认为是在并发进行。


B.随机性：在运行时，每次的结果不同。由于多个线程都在获取cpu的执行权，cpu执行到哪个线程，哪个线程就会执行。可以将多线程运行的行为形象的称为互相抢夺cpu的执行权。这就是多线程的特点，随机性。执行到哪个程序并不确定。




 

 

 

实现Runnable接口步骤：
 

 
 
a、定义类实现Runnable接口。
 
 
b、覆盖Runnable接口中的run方法。
 
 
c、通过Thread类建立线程对象。要运行几个线程，就创建几个对象。
 
 
d、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。(因为自定义的run方法所属对象为Runnable接口的子类对象，所以让线程指定对象的run方法，就必须明确该run方法所属的对象。)
 
 
e、调用Thread类的start方法开启线程，并调用Runnable接口子类的run方法。
 
 
  

 

 
 
<span style="font-family: Arial; ">
//多个窗口同时卖票
class Ticket implements Runnable
{
	private int tic = 20;
	public void run()
	{
		while(true)
		{
			if (tic > 0)
				System.out.println(Thread.currentThread().getName() + "sale:" + tic--);
		}
	}
}

class  TicketDemo
{
	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();
	}
}
</span>
 
 


 
 
实现方式与继承方式有何区
 
 

 
 
 
1、实现方式：避免了单继承的局限性。
 
 
             在定义线程时，建议使用实现方式。
 
 
2、区别：
 
 
继承Thread：线程代码存放在Thread子类的run方法中。
 
 
实现Runnable：线程代码存在接口的子类run方法中。
 
 
注意：局部变量在每一个线程中都独有一份。
 
 

 
 
 Thread类中的一些方法 

 

 
 
  

 

 
 1、获取线程名称：getName() 

 

 
 每个线程都有自己默认的名称，获取格式：对象.getName();打印后，显示为：Thread-编号（从0开始），也就是说，线程一为：Thread-0，线程二为：Thread-1。也可以获取当前线程对象的名称，通过currentThread().getName()。
  
 
2、设置线程名称：setName()或构造函数
 
 
可以通过setName()设置线程名称，或者通过含有参数的构造函数直接显式初始化线程的名称，如Test(String name)。
 
  
 
 
  
  
 
 
 线程的运行状态 
 
 

 

 
 
  

 

 
 a、被创建      b、运行      c、阻塞       d、冻结     e、消亡      

 

 
 
  

 

 
 多线程的安全问题 

 

 
 
  

 

 
 当存在共享数据时，由于多个线程访问时状态的不确定性导致共享数据出错。 

 

 
 解决方法： 

 

 
 a、同步代码块 

 

 
 
<span style="font-family: Arial; ">
synchronized(对象)//对象称为锁旗标
{
	需要被同步的代码
}</span><span style="font-family: SimSun; font-size: 14px; ">
</span>
 
 其中的对象如同锁，持有锁的线程可在同步中执行，没有锁的线程，即使获得cpu的执行权，也进不去，因为没有获取锁，是进不去代码块中执行共享数据语句的。
  

 

 
 b、同步函数 

 

 
 同步函数就是将修饰符synchronized放在返回类型的前面 

 

 
 非静态同步函数中的锁---> this
  

 

 
 
<span style="font-family: Arial; ">
class Ticket implements Runnable
{
	private int tic = 100;
	boolean flog = true;
	public void run()
	{
		if (flog)
		{
			//线程一执行
			while(true)
			{
				//如果对象为obj，则是两个锁，是不安全的；换成this，为一个锁，会安全很多
				synchronized(this)
				{
					if (tic > 0)
						System.out.println(Thread.currentThread().getName() + "--cobe--:" + tic--);
				}
			}
		}
		//线程二执行
		else
			while(true)
				show();
	}
	public synchronized void show()
	{
		if (tic > 0)
			System.out.println(Thread.currentThread().getName() + "----show-----:" + tic--);
	}
}

class ThisLockDemo
{
	public static void main(String[] args) 
	{
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);//创建一个线程
		Thread t2 = new Thread(t);//创建一个线程
		t1.start();
		t.flog = false;//开启线程一，即关闭if，让线程二执行else中语句
		t2.start();
	}
}</span>

 
 c、静态同步函数
  
 
静态同步函数中的锁：
 
 
如果同步函数被静态修饰后，经验证，使用的锁不是this了，因为静态方法中不可定义this，所以，这个锁不再是this了。静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象：类名.class；该对象的类型是Class。
 
  
 
 
  
  
 
 
 多线程间的通信 
 
 

 

 
 
  

 

 
 生产者和消费者的例子：
  

 

 
 
/*
线程间通信：

等待唤醒机制：升级版

生产者消费者  多个

*/
import java.util.concurrent.locks.*;

class ProducerConsumerDemo{
	public static void main(String[] args){
		Resouse r = new Resouse();
		Producer p = new Producer(r);
		Consumer c = new Consumer(r);
		Thread t1 = new Thread(p);
		Thread t2 = new Thread(c);
		Thread t3 = new Thread(p);
		Thread t4 = new Thread(c);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

class Resouse{
	private String name;
	private int count = 1;
	private boolean flag =  false; 
	private Lock lock = new ReentrantLock();
	private Condition condition_P = lock.newCondition();
	private Condition condition_C = lock.newCondition();
//要唤醒全部，否则都可能处于冻结状态，那么程序就会停止。这和死锁有区别的。
	public void set(String name)throws InterruptedException{
		lock.lock();
		try{
			while(flag)//循环判断，防止都冻结状态
				condition_P.await();
			this.name = name + "--" + count++;
			System.out.println(Thread.currentThread().getName() + "..生成者--" + this.name);
			flag = true;
			condition_C.signal();
		}finally{
			lock.unlock();//释放锁的机制一定要执行
		}		
	}
	public void out()throws InterruptedException{
		lock.lock();
		try{
			while(!flag)//循环判断，防止都冻结状态
				condition_C.await();
			System.out.println(Thread.currentThread().getName() + "..消费者." + this.name);
			flag = false;
			condition_P.signal();//唤醒全部
		}finally{
			lock.unlock();
		}
	}
}

class Producer implements Runnable{
	private Resouse r;
	Producer(Resouse r){
		this.r = r;
	}
	public void run(){
		while(true){
			try{
				r.set("--商品--");
			}catch (InterruptedException e){}
		}
	}
}

class Consumer implements Runnable{
	private Resouse r;
	Consumer(Resouse r){
		this.r = r;
	}
	public void run(){
		while(true){
			try{
				r.out();
			}catch (InterruptedException e){}
		}
	}
}
 
 
 等待唤醒机制
  

 

 
 
  

 

 
 
一）等待唤醒机制：
 
 
1、显式锁机制和等待唤醒机制：
 
 
在JDK 1.5中，提供了改进synchronized的升级解决方案。将同步synchronized替换为显式的Lock操作，将Object中的wait，notify，notifyAll替换成Condition对象，该对象可对Lock锁进行获取。这就实现了本方唤醒对方的操作。在这里说明几点：
 
 
1）、对于wait，notify和notifyAll这些方法都是用在同步中，也就是等待唤醒机制，这是因为要对持有监视器（锁）的线程操作。所以要使用在同步中，因为只有同步才具有锁。
 
 
2）、而这些方法都定义在Object中，是因为这些方法操作同步中的线程时，都必须表示自己所操作的线程的锁，就是说，等待和唤醒的必须是同一把锁。不可对不同锁中的线程进行唤醒。所以这就使得程序是不良的，因此，通过对锁机制的改良，使得程序得到优化。
 
 
3）、等待唤醒机制中，等待的线程处于冻结状态，是被放在线程池中，线程池中的线程已经放弃了执行资格，需要被唤醒后，才有被执行的资格。
 
 
2、对于上面的程序，有两点要说明：
 
 
1）、为何定义while判断标记：
 
 
原因是让被唤醒的线程再判断一次。
 
 
避免未经判断，线程不知是否应该执行，就执行本方的上一个已经执行的语句。如果用if，消费者在等着，两个生成着一起判断完flag后，cpu切换到其中一个如t1，另一个t3在wait，当t1唤醒冻结中的一个，是t3（因为它先被冻结的，就会先被唤醒），所以t3未经判断，又生产了一个。而没消费。
 
 
 
2）这里使用的是signal方法，而不是signalAll方法。是因为通过Condition的两个对象，分别唤醒对方，这就体现了Lock锁机制的灵活性。可以通过Contidition对象调用Lock接口中的方法，就可以保证多线程间通信的流畅性了。
 
 
二）Thread类中的方法简介：
 
 
在这简单介绍几个Thread中的方法：
 
 
1、停止线程：
 
 
在java 1.5之后，就不再使用stop方法停止线程了。那么该如何停止线程呢？只有一种方法，就是让run方法结束。
 
 
开启多线程运行，运行代码通常为循环结构，只要控制住循环，就可以让run方法结束，也就可以使线程结束。
 
 
注：
 
 
特殊情况：当线程处于冻结状态，就不会读取标记，那么线程就不会结束。如下：
 
 
<span style="font-family: Arial; ">class StopThread implements Runnable{
	private boolean flag = true;
	public synchronized void run(){
		while (flag){
			try{
				wait();
			}catch (InterruptedException e)	{
				System.out.println(Thread.currentThread().getName() + "----Exception");
				flag = false;
			}
			System.out.println(Thread.currentThread().getName() + "----run");
		}
	}
	public void changeFlag(){
		flag = false;
	}
}

class  StopThreadDemo{
	public static void main(String[] args) {
		StopThread st = new StopThread();

		Thread t1 = new Thread(st);
		Thread t2 = new Thread(st);
		
		t1.start();
		t2.start();

		int n = 0;
		while (true){
			if (n++ == 60){
				st.changeFlag();
				break;
			}
			System.out.println("Hello World!");
		}
	}
}</span>

 
 
 这时，当没有指定的方式让冻结的线程回复打破运行状态时，就需要对冻结进行清除。强制让线程回复到运行状态来，这样就可以操作标记让线程结束。 
 
 
 
在Thread类中提供了此种方法：interrupt()。此方法是为了让线程中断，但是并没有结束运行，让线程恢复到运行状态，再判断标记从而停止循环，run方法结束，线程结束。
 
 
<span style="font-family: Arial; ">class StopThread implements Runnable{
	private boolean flag = true;
	public synchronized void run(){
		while (flag){
			try{
				wait();
			}catch (InterruptedException e){
				System.out.println(Thread.currentThread().getName() + "----Exception");
				flag = false;
			}
			System.out.println(Thread.currentThread().getName() + "----run");
		}
	}
}

class  StopThreadDemo{
	public static void main(String[] args){
		StopThread st = new StopThread();
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(st);		
		t1.start();
		t2.start();
		int n = 0;
		while (true){
			if (n++ == 60){
				t1.interrupt();
				t2.interrupt();
				break;
			}
			System.out.println("Hello World!");
		}
	}
}
</span>
 
 
 2、守护线程：---setDaemon() 
 
 
 
可将一个线程标记为守护线程，直接调用这个方法。此方法需要在启动前调用守护线程在这个线程结束后，会自动结束，则Jvm虚拟机也结束运行。
 
 3、临时加入线程：--join() 
 
 
 
特点：当A线程执行到B线程方法时，A线程就会等待，B线程都执行完，A才会执行。join可用来临时加入线程执行。
 
 4、优先级： 
 
 
 
setPriority()：
 
 
在Thread中，存在着1~10这十个执行级别，最高的是 MAX_PRIORITY 为10，最低是 MIN_PRIORITY 为1，默认优先级是 NORM_PRIORITY 为5；但是并不是优先级越高，就会一直执行这个线程，只是说会优先执行到这个线程，此后还是有其他线程会和此线程抢夺cpu执行权的。
 
 
yield()：
 
 
此方法可暂停当前线程，而执行其他线程。通过这个方法，可稍微减少线程执行频率，达到线程都有机会平均被执行的效果。
 
 
 
 
写出一个死锁程序
 
 
 
  
class Test implements Runnable
{
	private boolean flag; // 定义标记
	Test(boolean flag)
	{
		this.flag = flag;
	}

	public void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(MyLock.locka)
				{
					System.out.println(Thread.currentThread().getName()+"...if locka ");
					synchronized(MyLock.lockb)   //在locka中需要lockb锁
					{
						System.out.println(Thread.currentThread().getName()+"..if lockb");					
					}
				}
			}
		}
		else
		{
			while(true)
			{
				synchronized(MyLock.lockb)
				{
					System.out.println(Thread.currentThread().getName()+"..else lockb");
					synchronized(MyLock.locka)  在lockb中需要locka锁
					{
						System.out.println(Thread.currentThread().getName()+".....else locka");
					}
				}
			}
		}
	}
}


class MyLock
{
	static Object locka = new Object();
	static Object lockb = new Object();
}

class  DeadLockTest
{
	public static void main(String[] args) 
	{
		Thread t1 = new Thread(new Test(true));
		Thread t2 = new Thread(new Test(false));
		t1.start();
		t2.start();
	}
}
 
  
 
  
 
 
 
 
 
 
 
 
  

 

 


  ---------------------- 
   
 JavaEE+Android、Java培训、期待与您交流！ ---------------------- 

 

详细请查看： http://edu.csdn.net

                

        

        

    

  


    

      

        

            

              
                
                  花心小土豆
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
黑马程序员多线程实现方式三

				
			

			

				

					qq_54478385的博客
				

				

					07-05
					
					182
					
				

			

		

		

			
				
学习

			
		

	



                

              
                



	

		

			

				
					
黑马程序员——多线程-整理笔记

				
			

			

				

					nanfp的博客
				

				

					07-06
					
					898
					
				

			

		

		

			
				
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------


多线程的概念：
          首先介绍什么是进程：进程是正在执行的程序，每个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元
          线程是其实就是进程中一个独立的控制单元，线程在控制着执行，一个进程至少有一个线程。
线程和进程的不同：
  

			
		

	



                


  
              

                


	

		

			

				
					
Java黑马程序员-多线程笔记

				
			

			

				

					luohanisme的博客
				

				

					10-17
					
					1038
					
				

			

		

		

			
				
哔哩哔哩java黑马视频笔记

			
		

	





	

		

			

				
					
黑马程序员_多线程

				
			

			

				

					weixin_51429898的博客
				

				

					01-17
					
					1065
					
				

			

		

		

			
				
多线程的基础知识

			
		

	



		

			
		



	

		

			

				
					
黑马程序员多线程视频总结

				
			

			

				

					fordushao的博客
				

				

					12-24
					
					921
					
				

			

		

		

			
				
线程池的工作模型主要两部分组成，一部分是运行Runnable的Thread对象，另一部分就是阻塞队列。由线程池创建的Thread对象其内部的run方法会通过阻塞队列的take方法获取一个Runnable对象，然后执行这个Runnable对象的run方法（即，在Thread的run方法中调用Runnable对象的run方法）。当Runnable对象的run方法执行完毕以后，Thread中的run方法又

			
		

	





	

		

			

				
					
黑马程序员   多线程

				
			

			

				

					baidu_25218715的博客
				

				

					08-26
					
					349
					
				

			

		

		

			
				
------- android培训、java培训、期待与您交流！ ----------




1、概述：
多线程（英语：multithreading），是指从软件或者硬件上实现多个线程并发执行的技术，即在同一时刻运行多个程序的能力。通常我们将可以同时执行多个任务的程序称为多线程程序，而把每一个任务都称为线程。多线程可以给其他任务提供机会，由于多线程的本质是CP在多个线程中快速切换，所

			
		

	





	

		

			

				
					
黑马程序员  多线程通信

				
			

			

				

					baidu_25218715的博客
				

				

					08-27
					
					438
					
				

			

		

		

			
				
学习java的过程中，我们经常能碰到多个线程任务操作一个共享数据的情况，反应到生活中，比如多个窗口卖票，票的总数固定，有的窗口卖的多有的卖的少，但是每一张票在多个窗口只能被卖出去一次。像涉及到多线程操作共享数据的情况，我们一般把这些情况称为多线程通信。
在多线程通信中有哪些要注意的呢，或者说怎么编译好一个多线程通信的程序呢。我觉得有以下几个要点

1．      明确要操作的共享数据
2．

			
		

	





	

		

			

				
					
黑马程序员 多线程异步集合笔记

				
			

			

				

					lazy_xia的专栏
				

				

					03-14
					
					595
					
				

			

		

		

			
				
---------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

多线程 异步处理




抽象类和接口的区别
    abstract可以修饰抽象方法 而一个类只要有一个抽象方法 就必须用abstract定义该类 即抽象类
    用interface修饰的类  里面的方法都是抽象方法 因此在定义接口的时候 可以直接不加

			
		

	





	

		

			

				
					
黑马程序员多线程实现方式二

				
			

			

				

					qq_54478385的博客
				

				

					07-05
					
					87
					
				

			

		

		

			
				
学习

			
		

	





	

		

			

				
					
黑马程序员–Java多线程讲解笔记

				
			

			

				

					12-22
				

			

		

		

			
				
Java多线程是Java编程中不可或缺的部分，它允许程序同时执行多个任务，提高了程序的效率和响应速度。本文主要探讨了多线程的概念、应用场景...因此，理解和掌握Java的多线程技术对于任何Java程序员来说都是至关重要的。

			
		

	





	

		

			

				
					
多线程高新(黑马程序员)

				
			

			

				

					04-03
				

			

		

		

			
				
本文将深入探讨“多线程高新”这一主题，结合黑马程序员的课程内容，来阐述多线程的核心概念、优势、实现方式以及在实际应用中的注意事项。  首先，多线程是指在一个进程中同时执行多个线程，这些线程可以共享同一...

			
		

	





	

		

			

				
					
黑马程序员多线程练习题

				
			

			

				

					08-23
				

			

		

		

			
				
黑马程序员多线程练习题主要包括两个问题。第一个问题是如何控制四个线程在打印log之前能够同时开始等待1秒钟。一种解决思路是在线程的run方法中调用parseLog方法，并使用Thread.sleep方法让线程等待1秒钟。另一种...

			
		

	





	

		

			

				
					
考研复习-英语二真题考试题集-带答案

				
			

			

				

					09-14
				

			

		

		

			
				
英语二考研真题复习资料，带答案版

			
		

	





	

		

			

				
					
2024中美独角兽公司发展分析报告.pdf

				
			

			

				

					09-14
				

			

		

		

			
				
全球各大洲独角兽企业分布、中美独角兽企业对比（数量、估值、新增及退榜情况、行业分布、所在城市）、

			
		

	





	

		

			

				
					
C++ 中的异步编程模型是什么

				
			

			

				

					09-14
				

			

		

		

			
				
在C++中，异步编程模型是处理并发任务、提高程序性能和响应性的关键技术。以下是C++中实现异步编程的几种主要方式：
每种异步编程模型都有其适用场景和优缺点。选择合适的模型可以提高代码的可读性、可维护性和性能。随着C++标准的不断发展，异步编程模型也在不断进化，为开发者提供了更多的工具和选择。

在实际开发中，应根据具体需求选择合适的异步编程模型。例如，对于简单的异步任务，回调函数可能是最直接的选择；而对于需要结构化错误处理和结果获取的复杂异步任务，std::async和std::future可能更合适；在需要高效资源管理的场景下，线程池是一个不错的选择；而对于需要编写大量异步代码的现代应用程序，协程提供了一种更简洁、更直观的解决方案。

总之，C++中的异步编程模型是多核和高并发环境下提高程序性能的重要工具。通过合理使用这些模型，开发者可以构建出更高效、更可靠的软件系统。

			
		

	





	

		

			

				
					
正则表达式Regex是一种文本模式.docx

				
			

			

				

					09-14
				

			

		

		

			
				
正则表达式（Regular Expression，简称Regex或Regexp）是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。正则表达式是强大的文本处理工具，广泛用于搜索、编辑或操作文本和数据。

基本组成
普通字符：大多数字符，包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号，都是普通字符。正则表达式中的普通字符表示它们自身。例如，正则表达式test会匹配字符串"test"。
特殊字符（元字符）：一些字符在正则表达式中具有特殊的意义，如^、$、.、*、+、?、{、}、[、]、|、\等。这些特殊字符用于表示在搜索文本时要匹配的一个或多个字符。例如，.匹配除换行符之外的任何单个字符。
字符类：字符类允许你指定一组字符中的任何一个字符。例如，[abc]匹配"a"、"b"或"c"中的任意一个字符。你也可以使用范围，如[a-z]匹配任何小写字母。
预定义字符类：正则表达式提供了一些预定义字符类，用于匹配常见的字符集合。例如，\d匹配任何数字（等价于[0-9]），\s匹配任

			
		

	





	

		

			

				
					
基于struts+sqlserver网络购物系统毕业课程源码设计+论文资料

				
			

			

				

					09-14
				

			

		

		

			
				
编号：150
系统功能：
 展示网站最新的商品信息。
 展示网站特价的商品信息。
 为用户提供修改个人资料和查看在网站操作情况的平台。
 提供用户在网站上购物的平台。
 展示网站发布的公告信息。
 展示商品的销量排行。
 展示网站的友情链接信息。
 对商品详细信息以及分类信息进行管理。
 对用户基本资料、交易制度、消费情况及留言信息进行管理。
 对用户提交的订单进行管理。
 对管理员信息、网站公告信息、商业资讯信息及友情链接信息进行管理。
 系统运行稳定，具有强大的数据处理能力。
操作注意事项
（1）本系统的用户名为：admin，密码为：admin
（2）admin管理员的信息不能删除。
（3）用户注册登录后，可进行商品购买、商品信息查看以及订单查询操作。
（4）后台登陆地址：http://localhost:8080/WebShopping/bg-land.jsp。

			
		

	





	

		

			

				
					
基于ssm的高校毕业生就业管理系统设计与实现.docx

					
最新发布

				
			

			

				

					09-14
				

			

		

		

			
				
基于ssm的高校毕业生就业管理系统设计与实现.docx

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值