多线程与MySQL

Posted 冷风中行走~

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了多线程与MySQL相关的知识,希望对你有一定的参考价值。

1.1 多线程

在传统操作系统中,每个进程有一个地址空间,而且默认就有一个控制线程

  线程顾名思义,就是一条流水线工作的过程,一条流水线必须属于一个车间,一个车间的工作过程是一个进程

    车间负责把资源整合到一起,是一个资源单位,而一个车间内至少有一个流水线

    流水线的工作需要电源,电源就相当于cpu

  所以,进程只是用来把资源集中到一起(进程只是一个资源单位,或者说资源集合),而线程才是cpu上的执行单位。

  多线程(即多个控制线程)的概念是,在一个进程中存在多个控制线程,多个控制线程共享该进程的地址空间,相当于一个车间内有多条流水线,都共用一个车间的资源。

     例如,北京地铁与上海地铁是不同的进程,而北京地铁里的13号线是一个线程,北京地铁所有的线路共享北京地铁所有的资源,比如所有的乘客可以被所有线路拉。

l  创建进程的开销要远大于线程?

如果我们的软件是一个工厂,该工厂有多条流水线,流水线工作需要电源,电源只有一个即cpu(单核cpu),一个车间就是一个进程,一个车间至少一条流水线(一个进程至少一个线程),创建一个进程,就是创建一个车间(申请空间,在该空间内建至少一条流水线),而建线程,就只是在一个车间内造一条流水线,无需申请空间,所以创建开销小

l  进程之间是竞争关系,线程之间是协作关系?

车间直接是竞争/抢电源的关系,竞争(不同的进程直接是竞争关系,是不同的程序员写的程序运行的,迅雷抢占其他进程的网速,360把其他进程当做病毒干死),一个车间的不同流水线式协同工作的关系(同一个进程的线程之间是合作关系,是同一个程序写的程序内开启动,迅雷内的线程是合作关系,不会自己干自己)

1.1.1 为何要用多线程

  多线程指的是,在一个进程中开启多个线程,简单的讲:如果多个任务共用一块地址空间,那么必须在一个进程内开启多个线程。详细的讲分为4点:

  1. 多线程共享一个进程的地址空间

    2. 线程比进程更轻量级,线程比进程更容易创建可撤销,在许多操作系统中,创建一个线程比创建一个进程要快10-100倍,在有大量线程需要动态和快速修改时,这一特性很有用

    3. 若多个线程都是cpu密集型的,那么并不能获得性能上的增强,但是如果存在大量的计算和大量的I/O处理,拥有多个线程允许这些活动彼此重叠运行,从而会加快程序执行的速度。

4. 在多cpu系统中,为了最大限度的利用多核,可以开启多个线程,比开进程开销要小的多。(这一条并不适用于python)

 

 

 

1.2 死锁现象与递归锁

进程也有死锁与递归锁。

所谓死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程。

  递归锁,在Python中为了支持在同一线程中多次请求同一资源,python提供了可重入锁RLock,

这个RLock内部维护着一个Lock和一个counter变量,counter记录了acquire的次数,从而使得资源可以被多次require。直到一个线程所有的acquire都被release,其他的线程才能获得资源。上面的例子如果使用RLock代替Lock,则不会发生死锁:

 

from threading import Thread,Lock,RLock

import time

 

# mutexA=Lock()

# mutexB=Lock()

 

mutexA=mutexB=RLock()  #一个线程拿到锁,counter加1,该线程内又碰到加锁的情况,则counter继续加1,这期间所有其他线程都只能等待,等待该线程释放所有锁,即counter递减到0为止

 

class MyThread(Thread):

    def run(self):

        self.f1()

        self.f2()

 

    def f1(self):

        mutexA.acquire()

        print(%s 拿到了A锁 %self.name)

 

        mutexB.acquire()

        print(%s 拿到了B锁 % self.name)

        mutexB.release() #1

 

        mutexA.release() #0

 

    def f2(self):

        mutexB.acquire()

        print(%s 拿到了B锁 % self.name)

        time.sleep(0.1)

 

        mutexA.acquire()

        print(%s 拿到了A锁 % self.name)

        mutexA.release()

 

        mutexB.release()

 

 

 

if __name__ == __main__:

    for i in range(10):

        t=MyThread()

        t.start()

 

 

1.3 信号量Semaphore

同进程的一样,Semaphore管理一个内置的计数器,每当调用acquire()时内置计数器-1;调用release() 时内置计数器+1;计数器不能小于0;当计数器为0时,acquire()将阻塞线程直到其他线程调用release()。

实例:(同时只有5个线程可以获得semaphore,即可以限制最大连接数为5):

from threading import Thread,Semaphore,current_thread

import time,random

 

sm=Semaphore(5)

 

def task():

    with sm:

        print(%s is laing %current_thread().getName())

        time.sleep(random.randint(1,3))

 

if __name__ == __main__:

    for i in range(20):

        t=Thread(target=task)

        t.start()

 

与进程池是完全不同的概念,进程池Pool(4),最大只能产生4个进程,而且从头到尾都只是这四个进程,不会产生新的,而信号量是产生一堆线程/进程

1.4 Event事件

同进程的一样,线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行

event.isSet():返回event的状态值;

 

event.wait():如果 event.isSet()==False将阻塞线程;

 

event.set(): 设置event的状态值为True,所有阻塞池的线程激活进入就绪状态, 等待操作系统调度;

 

event.clear():恢复event的状态值为False。

 

 

例如,有多个工作线程尝试链接mysql,我们想要在链接前确保MySQL服务正常才让那些工作线程去连接MySQL服务器,如果连接不成功,都会去尝试重新连接。那么我们就可以采用threading.Event机制来协调各个工作线程的连接操作

from threading import Thread,Event,current_thread

import time

 

event=Event()

 

def check():

    print(checking MySQL...)

    time.sleep(5)

    event.set()

 

def conn():

    count=1

    while not event.is_set():

        if count > 3:

            raise TimeoutError(超时)

        print(%s try to connect MySQL time %s %(current_thread().getName(),count))

        event.wait(1)

        count+=1

 

    print(%s connected MySQL %current_thread().getName())

 

if __name__ == __main__:

    t1=Thread(target=check)

    t2=Thread(target=conn)

    t3=Thread(target=conn)

    t4=Thread(target=conn)

 

 

    t1.start()

    t2.start()

    t3.start()

    t4.start()

 

 

1.5 定时器

定时器,指定n秒后执行某操作

from threading import Timer

 

 

def hello(name):

    print("hello, world %s " %name)

 

 

t = Timer(3, hello,args=(egon,))

t.start()  # after 1 seconds, "hello, world" will be printed

 

 

1.6 线程queue

queue队列 :使用import queue,用法与进程Queue一样

import queue

 

q=queue.Queue(3) #队列:先进先出

 

q.put(1)

q.put(2)

q.put(3)

# q.put(4)

# q.put_nowait(4)

# q.put(4,block=False)

q.put(4,block=True,timeout=3)

 

 

# print(q.get())

# print(q.get())

# print(q.get())

 

q=queue.LifoQueue(3) #堆栈:后进先出

q.put(1)

q.put(2)

q.put(3)

 

print(q.get())

print(q.get())

print(q.get())

 

q=queue.PriorityQueue(3) #优先级队列

q.put((10,a))

q.put((-3,b))

q.put((100,c))

 

print(q.get())

print(q.get())

print(q.get())

 

 

 

1.7 进程池线程池

#提交任务的两种方式:

#同步调用:提交完任务后,就在原地等待,等待任务执行完毕,拿到任务的返回值,才能继续下一行代码,导致程序串行执行

#异步调用+回调机制:提交完任务后,不在原地等待,任务一旦执行完毕就会触发回调函数的执行, 程序是并发执行

 

#进程的执行状态:

#阻塞

#非阻塞

 

 

1.7.1 同步调用示例:

# from multiprocessing import Pool

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

import time,random,os

 

def task(n):

    print(%s is ruuning %os.getpid())

    time.sleep(random.randint(1,3))

    return n**2

 

def handle(res):

    print(handle res %s %res)

 

if __name__ == __main__:

    #同步调用

    pool=ProcessPoolExecutor(2)

 

    for i in range(5):

        res=pool.submit(task,i).result()

        # print(res)

        handle(res)

 

    pool.shutdown(wait=True)

    # pool.submit(task,33333)

    print()

 

 

 

1.7.2 异步调用示例:

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

import time,random,os

 

def task(n):

    print(%s is ruuning %os.getpid())

    time.sleep(random.randint(1,3))

    # res=n**2

    # handle(res)

    return n**2

 

def handle(res):

    res=res.result()

    print(handle res %s %res)

 

if __name__ == __main__:

    #异步调用

    pool=ProcessPoolExecutor(2)

 

    for i in range(5):

        obj=pool.submit(task,i)

        obj.add_done_callback(handle) #handle(obj)

 

    pool.shutdown(wait=True)

    print()

 

 

 

1.7.3 线程池

from concurrent.futures import ThreadPoolExecutor

from threading import current_thread

import requests

import time

 

def get(url):

    print(%s GET %s %(current_thread().getName(),url))

    response=requests.get(url)

    time.sleep(2)

    if response.status_code == 200:

        return {url:url,content:response.text}

 

def parse(res):

    res=res.result()

    print(parse:[%s] res:[%s] %(res[url],len(res[content])))

 

 

if __name__ == __main__:

    pool=ThreadPoolExecutor(2)

 

    urls=[

        https://www.baidu.com,

        https://www.python.org,

        https://www.openstack.org,

        https://www.openstack.org,

        https://www.openstack.org,

        https://www.openstack.org,

        https://www.openstack.org,

        https://www.openstack.org,

        https://www.openstack.org,

        https://www.openstack.org,

        https://www.openstack.org,

        https://www.openstack.org,

    ]

    for url in urls:

        pool.submit(get,url).add_done_callback(parse)

 

    pool.shutdown(wait=True)

 

 

1.8 协程

单纯地切换反而会降低运行效率

协程:是单线程下的并发,又称微线程,纤程。英文名Coroutine。一句话说明什么是线程:协程是一种用户态的轻量级线程,即协程是由用户程序自己控制调度的。

总结协程特点:

必须在只有一个单线程里实现并发

修改共享数据不需加锁

用户程序里自己保存多个控制流的上下文栈

附加:一个协程遇到IO操作自动切换到其它协程(如何实现检测IO,yield、greenlet都无法实现,就用到了gevent模块(select机制))

1.8.1 串行执行

import time

def consumer(res):

    ‘‘‘任务1:接收数据,处理数据‘‘‘

    pass

 

def producer():

    ‘‘‘任务2:生产数据‘‘‘

    res=[]

    for i in range(10000000):

        res.append(i)

    return res

 

start=time.time()

#串行执行

res=producer()

consumer(res)

stop=time.time()

print(stop-start)

 

 

 

 

1.8.2 基于yield并发执行

import time

def consumer():

    ‘‘‘任务1:接收数据,处理数据‘‘‘

    while True:

        print(consumer)

        x=yield

        time.sleep(100)

 

def producer():

    ‘‘‘任务2:生产数据‘‘‘

    g=consumer()

    next(g)

    for i in range(10000000):

        print(producer)

        g.send(i)

 

start=time.time()

#基于yield保存状态,实现两个任务直接来回切换,即并发的效果

#PS:如果每个任务中都加上打印,那么明显地看到两个任务的打印是你一次我一次,即并发执行的.

producer()

 

stop=time.time()

print(stop-start) #

 

 

1.9 greenlet模块

如果我们在单个线程内有20个任务,要想实现在多个任务之间切换,使用yield生成器的方式过于麻烦(需要先得到初始化一次的生成器,然后再调用send。。。非常麻烦),而使用greenlet模块可以非常简单地实现这20个任务直接的切换

安装模块

pip3 install greenlet

 

 

from greenlet import greenlet

import time

 

def eat(name):

    print(%s eat 1 %name)

    time.sleep(1000)

    g2.switch(egon)

    print(%s eat 2 %name)

    g2.switch()

 

 

def play(name):

    print(%s play 1 % name)

    g1.switch()  #可以在第一次switch时传入参数,以后都不需要

    print(%s play 2 % name)

 

g1=greenlet(eat)

g2=greenlet(play)

 

greenlet只是提供了一种比generator更加便捷的切换方式,当切到一个任务执行时如果遇到io,那就原地阻塞,仍然是没有解决遇到IO自动切换来提升效率的问题。

单线程里的这20个任务的代码通常会既有计算操作又有阻塞操作,我们完全可以在执行任务1时遇到阻塞,就利用阻塞的时间去执行任务2。。。。如此,才能提高效率,这就用到了Gevent模块。

1.10 gevent模块

Gevent 是一个第三方库,可以轻松通过gevent实现并发同步或异步编程,在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部,但它们被协作式地调度。

#用法

g1=gevent.spawn(func,1,,2,3,x=4,y=5)创建一个协程对象g1,spawn括号内第一个参数是函数名,如eat,后面可以有多个参数,可以是位置实参或关键字实参,都是传给函数eat的

 

g2=gevent.spawn(func2)

 

g1.join() #等待g1结束

 

g2.join() #等待g2结束

 

#或者上述两步合作一步:gevent.joinall([g1,g2])

 

g1.value#拿到func1的返回值

 

 

from gevent import monkey;monkey.patch_all()

import gevent

import time

 

def eat(name):

    print(%s eat 1 %name)

    # gevent.sleep(3)

    time.sleep(3)

    print(%s eat 2 %name)

 

 

def play(name):

    print(%s play 1 % name)

    # gevent.sleep(2)

    time.sleep(3)

    print(%s play 2 % name)

 

g1=gevent.spawn(eat,egon)

g2=gevent.spawn(play,alex)

# gevent.sleep(1)

 

# g1.join()

# g2.join()

gevent.joinall([g1,g2])

 

练习

通过gevent实现单线程下的socket并发(from gevent import monkey;monkey.patch_all()一定要放到导入socket模块之前,否则gevent无法识别socket的阻塞)

服务端

from gevent import monkey,spawn;monkey.patch_all()

from threading import current_thread

from socket import *

 

def comunicate(conn):

    print(子线程:%s %current_thread().getName())

    while True:

        try:

            data=conn.recv(1024)

            if not data:break

            conn.send(data.upper())

        except ConnectionResetError:

            break

    conn.close()

 

def server(ip,port):

    print(主线程:%s %current_thread().getName())

    server = socket(AF_INET, SOCK_STREAM)

    server.bind((ip,port))

    server.listen(5)

 

    while True:

        conn, addr = server.accept()

        print(addr)

        # comunicate(conn)

        # t=Thread(target=comunicate,args=(conn,))

        # t.start()

        spawn(comunicate,conn)

 

    server.close()

 

if __name__ == __main__:

    g=spawn(server,127.0.0.1, 8081)

    g.join()

 

 

客户端

多线程并发多个客户端

from socket import *

from threading import current_thread,Thread

 

def client():

    client=socket(AF_INET,SOCK_STREAM)

    client.connect((127.0.0.1,8081))

 

    while True:

        client.send((%s say hello %current_thread().getName()).encode(utf-8))

        data=client.recv(1024)

        print(data.decode(utf-8))

 

    client.close()

 

if __name__ == __main__:

    for i in range(500):

        t=Thread(target=client)

        t.start()

 

 

 

1.11 MySQL数据库相关概念

MySQL是一个关系型数据库管理系统,由瑞典MySQL AB 公司开发,目前属于 Oracle 旗下公司。MySQL 最流行的关系型数据库管理系统,在 WEB 应用方面MySQL是最好的 RDBMS (Relational Database Management System,关系数据库管理系统) 应用软件之一。

1、数据库服务器:计算机

2、数据库管理软件:MySQL

3、数据库/库:文件夹

4、表:文件

5、记录:一个事物的一系列典型的特征:egon,male,18,oldgirl

6、数据:事物的特征,sex=‘male‘

1.11.1 mysql是什么

#mysql就是一个基于socket编写的C/S架构的软件

#客户端软件

  mysql自带:如mysql命令,mysqldump命令等

  python模块:如pymysql

 

1.11.2 数据库管理软件分类

#分两大类:

  关系型:如sqllite,db2,oracle,access,sql server,MySQL,注意:sql语句通用

  非关系型:mongodb,redis,memcache

#可以简单的理解为:

    关系型数据库需要有表结构

    非关系型数据库是key-value存储的,没有表结构

1.11.3 下载安装

1.11.3.1  Linux版本

一、二进制rpm包安装

yum -y install mysql-server mysql

 

 

二、源码安装

1.解压tar包

cd /software

tar -xzvf mysql-5.6.21-linux-glibc2.5-x86_64.tar.gz

mv mysql-5.6.21-linux-glibc2.5-x86_64 mysql-5.6.21

 

 

2.添加用户与组

groupadd mysql

useradd -r -g mysql mysql

chown -R mysql:mysql mysql-5.6.21

 

 

3.安装数据库

su mysql

cd mysql-5.6.21/scripts

./mysql_install_db --user=mysql --basedir=/software/mysql-5.6.21 --datadir=/software/mysql-5.6.21/data

 

 

4.配置文件

cd /software/mysql-5.6.21/support-files

cp my-default.cnf /etc/my.cnf

cp mysql.server /etc/init.d/mysql

vim /etc/init.d/mysql   #若mysql的安装目录是/usr/local/mysql,则可省略此步

修改文件中的两个变更值

basedir=/software/mysql-5.6.21

datadir=/software/mysql-5.6.21/data

 

 

5.配置环境变量

vim /etc/profile

export MYSQL_HOME="/software/mysql-5.6.21"

export PATH="$PATH:$MYSQL_HOME/bin"

source /etc/profile

 

 

6.添加自启动服务

chkconfig --add mysql

chkconfig mysql on

 

 

7.启动mysql

service mysql start

 

 

8.登录mysql及改密码与配置远程访问

mysqladmin -u root password your_password     #修改root用户密码

mysql -u root -p     #登录mysql,需要输入密码

mysql>GRANT ALL PRIVILEGES ON *.* TO root@% IDENTIFIED BY your_password WITH GRANT OPTION;     #允许root用户远程访问

mysql>FLUSH PRIVILEGES;     #刷新权限

 

 

三、源码安装mariadb

1. 解压
tar zxvf  mariadb-5.5.31-linux-x86_64.tar.gz  

mv mariadb-5.5.31-linux-x86_64 /usr/local/mysql //必需这样,很多脚本或可执行程序都会直接访问这个目录

 

 
2. 权限
groupadd mysql             //增加 mysql 属组

useradd -g mysql mysql     //增加 mysql 用户 并归于mysql 属组

chown mysql:mysql -Rf  /usr/local/mysql    // 设置 mysql 目录的用户及用户组归属。

chmod +x -Rf /usr/local/mysql    //赐予可执行权限

 

 
3. 拷贝配置文件
cp /usr/local/mysql/support-files/my-medium.cnf /etc/my.cnf     //复制默认mysql配置 文件到/etc目录

 

 
4. 初始化
/usr/local/mysql/scripts/mysql_install_db --user=mysql          //初始化数据库

cp  /usr/local/mysql/support-files/mysql.server    /etc/init.d/mysql    //复制mysql服务程序 到系统目录

chkconfig  mysql on     //添加mysql 至系统服务并设置为开机启动

service  mysql  start  //启动mysql

 

 
5. 环境变量配置
vim /etc/profile   //编辑profile,将mysql的可执行路径加入系统PATH

export PATH=/usr/local/mysql/bin:$PATH

source /etc/profile  //使PATH生效。

 

 
6. 账号密码
mysqladmin -u root password yourpassword //设定root账号及密码

mysql -u root -p  //使用root用户登录mysql

use mysql  //切换至mysql数据库。

select user,host,password from user; //查看系统权限

drop user ‘‘@localhost; //删除不安全的账户

drop user [email protected]::1;

drop user [email protected]127.0.0.1;

select user,host,password from user; //再次查看系统权限,确保不安全的账户均被删除。

flush privileges;  //刷新权限

 

 
7. 一些必要的初始配置
1)修改字符集为UTF8
vi /etc/my.cnf

在[client]下面添加 default-character-set = utf8

在[mysqld]下面添加 character_set_server = utf8

 

2)增加错误日志

vi /etc/my.cnf

在[mysqld]下面添加:

log-error = /usr/local/mysql/log/error.log

general-log-file = /usr/local/mysql/log/mysql.log

3) 设置为不区分大小写,linux下默认会区分大小写。

vi /etc/my.cnf

在[mysqld]下面添加:

lower_case_table_name=1 
修改完重启:
service  mysql  restart

 

 

1.11.3.2  Window版本

安装

#1、下载:MySQL Community Server 5.7.16

http://dev.mysql.com/downloads/mysql/

 

#2、解压

如果想要让MySQL安装在指定目录,那么就将解压后的文件夹移动到指定目录,如:C:\mysql-5.7.16-winx64

 

#3、添加环境变量

【右键计算机】--》【属性】--》【高级系统设置】--》【高级】--》【环境变量】--》【在第二个内容框中找到 变量名为Path 的一行,双击】 --> 【将MySQL的bin目录路径追加到变值值中,用 ; 分割】

 

#4、初始化

mysqld --initialize-insecure

 

 

#5、启动MySQL服务

mysqld # 启动MySQL服务

 

 

#6、启动MySQL客户端并连接MySQL服务

mysql -u root -p # 连接MySQL服务器

 

 

将MySQL服务制作成windows服务

上一步解决了一些问题,但不够彻底,因为在执行【mysqd】启动MySQL服务器时,当前终端会被hang住,那么做一下设置即可解决此问题:
注意:--install前,必须用mysql启动命令的绝对路径
# 制作MySQL的Windows服务,在终端执行此命令:
"c:\mysql-5.7.16-winx64\bin\mysqld" --install

 

 
# 移除MySQL的Windows服务,在终端执行此命令:
"c:\mysql-5.7.16-winx64\bin\mysqld" --remove

 

注册成服务之后,以后再启动和关闭MySQL服务时,仅需执行如下命令:
# 启动MySQL服务
net start mysql

 

# 关闭MySQL服务
net stop mysql

 

 

1.12 重置密码

1.12.1 设置密码

C:\Users\Administrator> mysqladmin -uroot -p password "123"

 

 

1.12.2 重置密码

net stop MySQL

mysqld --skip-grant-tables

mysql -uroot -p

    update mysql.user set password=password("") where user=root and host="localhost";

    flush privileges;

 

C:\Users\Administrator>tasklist |findstr mysql

mysqld.exe                    6316 Console                    1    454,544 K

 

C:\Users\Administrator>taskkill /F /PID 6316

成功: 已终止 PID 为 6316 的进程。

 

C:\Users\Administrator>net start MySQL

MySQL 服务正在启动 .

MySQL 服务已经启动成功。

 

 

1.13 统一字符编码

#1. 修改配置文件

[mysqld]

default-character-set=utf8

[client]

default-character-set=utf8

[mysql]

default-character-set=utf8

 

#mysql5.5以上:修改方式有所改动

[mysqld]

character-set-server=utf8

collation-server=utf8_general_ci

[client]

default-character-set=utf8

[mysql]

default-character-set=utf8

 

 

#2. 重启服务

#3. 查看修改结果:

mysql> \s

show variables like %char%

 

 

1.14 初识SQL

有了mysql这个数据库软件,就可以将程序员从对数据的管理中解脱出来,专注于对程序逻辑的编写

mysql服务端软件即mysqld帮我们管理好文件夹以及文件,前提是作为使用者的我们,需要下载mysql的客户端,或者其他模块来连接到mysqld,然后使用mysql软件规定的语法格式去提交自己命令,实现对文件夹或文件的管理。该语法即sql(Structured Query Language 即结构化查询语言)

SQL语言主要用于存取数据、查询数据、更新数据和管理关系数据库系统,SQL语言由IBM开发。SQL语言分为3种类型:

#1、DDL语句    数据库定义语言: 数据库、表、视图、索引、存储过程,例如CREATE DROP ALTER

#2、DML语句    数据库操纵语言: 插入数据INSERT、删除数据DELETE、更新数据UPDATE、查询数据SELECT

#3、DCL语句    数据库控制语言: 例如控制用户的访问权限GRANT、REVOKE

 

1.14.1 操作文件夹(库)

1.14.1.1  增

create database db1 charset utf8;

 

1.14.1.2  查

show databases;

show create database db1;

 

1.14.1.3  改

alter database db1 charset gbk;

 

1.14.1.4  删

drop database db1;

 

 

1.14.2 操作文件(表)

1.14.2.1  查看当前所在的文件夹:

select database();

 

1.14.2.2  切换文件夹:

use db1;

 

1.14.2.3  增

create table t1(id int,name char);

 

1.14.2.4  查

show tables;

show create table t1;

desc t1;

 

1.14.2.5  改

alter table t1 add sex char;

alter table t1 drop sex;

alter table t1 modify name char(16);

alter table t1 change name Name char(13);

 

1.14.2.6  删

drop table t1;

 

 

1.14.3 操作文件的内容(记录)

1.14.3.1  增

insert into db1.t1 values

 (1,egon),

 (2,alex),

 (3,wxx);

 

1.14.3.2  查

select id,name from db1.t1;

select * from db1.t1;

 

1.14.3.3  改

update t1 set name=SB where id=2;

 

1.14.3.4  删

delete from t1 where id=2;

 

 

1.15 存储引擎

储引擎即表类型,mysql根据不同的表类型会有不同的处理机制

查看引擎

show engines;

 

创建引擎

create table t1(id int)engine=innodb;

create table t2(id int)engine=myisam;

create table t3(id int)engine=memory;

create table t4(id int)engine=blackhole;

 

 

1.16 数值类型

1.16.1 整型(默认有符号)

create table t8(n tinyint);

insert into t8 values(-1);

insert into t8 values(128);

insert into t8 values(-129);

 

create table t9(n tinyint unsigned);

insert into t9 values(-1),(256);

 

 

#整型的宽度代表显示宽度

create table t11(n int(3) unsigned zerofill);

create table t12(n int unsigned zerofill);

 

create table t13(

    id int

);

 

 

 

 

 

1.16.2 浮点型

create table t13(x float(255,30));

create table t14(x double(255,30));

create table t15(x decimal(65,30));

 

 

insert into t13 values(1.111111111111111111111111111111);

insert into t14 values(1.111111111111111111111111111111);

insert into t15 values(1.111111111111111111111111111111);

 

 

1.17 日期类型

create table student(

    id int,

    name char(16),

    born_year year,

    birth_date date,

    class_time time,

    reg_time datetime

);

 

insert into student values

(1,egon,now(),now(),now(),now())

;

 

insert into student values

(2,alex,1999,1999-11-11,11:11:11,"1999-11-11 11:11:11")

 

 

1.18 字符类型

char:定长

varchar:变长

 

#宽度代表的是字符的个数

create table t16(name char(5));

create table t17(name varchar(5));

 

insert into t16 values(李杰 ); #‘李杰   ‘

insert into t17 values(李杰 ); #‘李杰 ‘

 

select char_length(name) from t16; #5

select char_length(name) from t17; #3

 

mysql> set sql_mode=PAD_CHAR_TO_FULL_LENGTH;

 

select * from t16 where name=李杰;

select * from t17 where name=李杰;

 

select * from t16 where name like 李杰;

 

name char(5)

egon |alex |wxx  |

 

 

name varchar(5)

1bytes+egon|1bytes+alex|1bytes+wxx|

 

1.19 枚举类型与集合类型

create table employee(

    id int,

    name char(10),

    sex enum(male,female,other),

    hobbies set(play,eat,music,read)

);

 

insert into employee values

(1,egon,male,music,read);

 

insert into employee values

(2,alex,xxxx,music,read);

 

以上是关于多线程与MySQL的主要内容,如果未能解决你的问题,请参考以下文章

多线程 Thread 线程同步 synchronized

多线程编程

Java多线程与并发库高级应用-工具类介绍

Java多线程与并发库高级应用-工具类介绍

多个用户访问同一段代码

线程学习知识点总结