导读：本篇文章首席CTO笔记来给大家介绍有关django如何处理阻塞的相关内容，希望对大家有所帮助，一起来看看吧。
c/s系统，如何防止用户直接连到数据库修改数据
1. 事实上，交易不帮你在这里多...除非你想有运行在多个HTTP请求（你很可能不希望）的交易。 有什么用在这些情况下是“乐观锁定”。 Django的ORM不支持，据我所知。但一直以来关于添加此功能。 那么，你是你自己的。基本上，你应该做的就是添加一个“版本”字段，你的模型，并把它传递给一个隐藏字段。正常周期的更新是： 读取数据并显示给 用户可以修改数据 用户发布的数据 该应用程序将其保存回数据库。 乐观锁，当你保存数据，你检查，如果你得到了从后面的版本是作为一个在数据库中，然后更新数据库和版本。如果它们不是，那有一直以来被加载的数据的变化。 你可以做到这一点与像一个单一的SQL调用：UPDATE ... WHERE version = 'version_from_user';
这个调用将更新数据库只有在版本仍然是
2. 我就是这样做的Django的乐观锁：updated = Entry.objects.filter(Q(id=e.id) Q(version=e.version))\
.update(updated_field=new_value, version=e.version+1)
if not updated:
raise ConcurrentModificationException()
上面列出的代码可以在自定义管理。 我提出以下假设： 筛选（）。update（）方法会导致在一个单一的数据库查询过滤器是懒惰 数据库查询是原子 这些假设都足以确保没有其他人之前已经更新了条目。如果有多个行被更新这样你的交易。 警告Django的文件： 请注意，update（）方法是 直接转换为SQL 这是一个批量操作 直接更新。它不运行任何 保存（您的模型）的方法，或发出 该pre_save或post_save信号
3. 这个问题是有点老了，我的回答有点晚，但经过我的理解使用这个已被固定在Django 1.4：select_for_update(nowait=True)
看到文档 返回一个QuerySet，将锁定行，直到事务结束，产生一个SELECT ...有关支持的数据库UPDATE的SQL。 通常情况下，如果另一个事务已获得所选择的行上的锁，则查询将阻塞，直到锁被释放。如果这不是你想要的行为，请致电select_for_update（NOWAIT=TRUE）。这将使调用非阻塞的。如果已经获取了冲突的锁被另一个事务时的QuerySet进行评估，DatabaseError的将得到提升。 当然，这只会工作，如果后端支持的“选择更新”功能，这对于例如SQLite不。不幸的是：nowait=True不支持MySql的，有你有nowait=False，这只会阻塞，直到锁被释放。
4. 对于未来的参考，退房离开的时候（在浏览器中，例如崩溃）的页面，并锁定它锁定的方式，不留下永恒的锁，通过javascript的解锁的混合物。下
5. 你应该Django的交易中间件，至少，甚至不管这个问题。 至于你实际有编辑数据的问题...是的，使用锁。或： 检查什么版本正在更新对（这样做牢固，不能简单地破解系统说，他们正在更新的最新副本！），且仅当该版本是最新的更新。否则，返回一个新页面与原来的版本，他们编辑，他们提交的版本，和别人写的新版本（S）。问他们变成一体，完全取决于最新的版本。你可以尝试类似的diff +补丁工具集，但你需要有方法工作失败的案例，无论如何，所以开始了。此外，您将需要保存的版本历史记录，并允许管理员恢复的变化，在无意的情况下或向上，但你应该有反正。 有很可能是Django应用程序/库，做这个最适合你。
6. 为了安全起见，数据库需要支持事务。 如果字段是“自由形式”如文字等等，你需要允许可以编辑的字段（你不能有所有权的数据），你可以存储在变量中的原始数据。 当committs，检查输入数据从原始数据更改（如果不是，你不需要通过重写旧数据打扰DB） 如果原来在数据库中的当前数据是可以保存，如果它改变了你可以示区别，并问该怎么办。 如果字段是一个数字如账户余额，在商店等项目的数量，你可以自动处理它，如果你计算出原始值（存储开始时填写表单）和新的价值，你就可以开始一个事务读取当前值之间的差额新增的差别，然后结束交易。如果你不能有负值，则应该中止交易，如果结果为负，并告诉 我不知道Django的，所以我不能给你德cod3s .. ;)
7. 另一个需要注意的是这个词“原子”.a个原子，你的数据库的更改要么发生或无法快速搜索说明这个问题问Django中的原子操作。
8. 上面的想法updated = Entry.objects.filter(Q(id=e.id) Q(version=e.version))\
.update(updated_field=new_value, version=e.version+1)
if not updated:
raise ConcurrentModificationException()
看起来不错，应该能正常运行，即使没有序列化的交易。 问题是如何将deafult。保存（）的行为，以不必须做人工管道来调用。update（）方法。 我看着自定义管理想法。 我的计划是覆盖被称为Model.save_base（）来执行更新的经理。 这是在Django 1.3当前代码def _update(self, values, **kwargs):
return self.get_query_set()._update(values, **kwargs)
什么需要恕我直言做的是这样的：def _update(self, values, **kwargs):
#TODO Get version field value
v = self.get_version_field_value(values[0])
return self.get_query_set().filter(Q(version=v))._update(values, **kwargs)
类似的事情需要发生的删除。但是删除是有点难度的Django是相当巫术在这方面通过django.db.models.deletion.Collector。 这是奇怪的，像Django的modren工具缺乏对Optimictic Concurency控制指导。 当我解开这个谜，我会更新这个帖子。希望解决方案将是不涉及万吨编码，怪异的意见，跳绳重要部分的Django等的一个很好的Python的方式
9. 从这里开始： 我假设将举行一个隐藏字段中你试图挽救细节的表格。def save(self):
if(self.id):
foo = Foo.objects.get(pk=self.id)
if(foo.timestamp self.timestamp):
raise Exception, "trying to save outdated Foo"
super(Foo, self).save()
很少用到多执行绪，多考虑高并发吗
很少用到多执行绪，多考虑高并发吗
1.多执行绪基本用在PHP做终端命令列执行是才会使用2.负载均衡是一个很大的词汇,里面包含的东西非常多.这里你是指的是分散式吧? 单纯的靠PHP做分散式是不可能的.我们常常用到一些其他专案来做,如风头正盛的hadoop等等
python 多执行绪支援并发吗
Imgur的API要求HTTP请求能支援带有client ID的“Authorization”头部。你可以从你注册的Imgur应用的面板上找到这个client ID，而响应会以JSON进行编码。
jquery ajax不能多执行绪并发吗
可以的，jquery的ajax可以同步也可以非同步，
ajax里面有个引数叫：async预设为true，非同步请求；通过它来设定请求方式；
web api 并发 多执行绪吗
应用伺服器的效能分析是复杂的，关注点很多。比如典型场景Web伺服器+资料库，底层网路链路和网路硬体效能姑且不论，单看：Web伺服器对静态档案的读写与磁碟和档案系统IO效能紧密相关；对资料的处理和资料库效能相关；而高并发访问则关系到作业系统的执行绪、网路套接字以及非同步网路模型的效率。
在资料量大的情况下，资料库的效能成为一个至关重要的因素，随之带来Web伺服器等待资料库的时间。在此基础上如果有大量的使用者同时访问，那么会对Web伺服器带来什么样的影响？以下主要讨论这个问题。
对于并发访问的处理，一般有两种处理机制：非同步非阻塞机制、多执行绪阻塞机制（介绍略）。在测试选择上，前者使用基于Python的Tornado伺服器，而后者使用基于Java的Tomcat伺服器。注意：本文并非讨论开发语言的优劣，事实上，新版本的Java也支援非同步机制，甚至高效能的epoll等。
java并发是多执行绪吗
当有多个执行绪在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的执行绪，它只能把CPU执行时间划分成若干个时间段,再将时间
段分配给各个执行绪执行，在一个时间段的执行绪程式码执行时，其它执行绪处于挂起状。.这种方式我们称之为并发(Concurrent)。
django 并发请求 是多执行绪吗
用Django搭了个环境，建立了一个App。
我想要测试假如同时多个请求进来Django的处理方式，于是写了一下程式码在View.py中：
Python code?
def archive(request):
print("start")
time.sleep(5)
print("end")
return HttpResponse("Hellow World")
高并发nginx伺服器是多程序还是多执行绪
Nginx会按需同时执行多个程序：一个主程序(master)和几个工作程序(worker)，配置了快取时还会有快取载入器程序(cache loader)和快取管理器程序(cache manager)等。Nginx主要通过“共享记忆体”的机制实现程序间通讯。主程序以root使用者身份执行，而worker、cache loader和cache manager均应以非特权使用者身份执行。
在工作方式上，Nginx分为单工作程序和多工作程序两种模式。在单工作程序模式下，除主程序外，还有一个工作程序，工作程序是单执行绪的；在多工作程序模式下，每个工作程序包含多个执行绪。Nginx预设为单工作程序模式。
sqlite3 多执行绪高并发的访问如何处理
# coding:utf-8
import sqlite3
import queue, os
def singleton(cls):
instances = {}
def _singleton(*args, **kw):
if cls not in instances:
instances[cls] = cls(*args, **kw)
return instances[cls]
return _singleton
@singleton
class SQLiteUtil(object):
__queue_conn = queue.Queue(maxsize=1)
__path = None
def __init__(self, path):
self.__path = path
print('path:', self.__path)
self.__create_conn()
def __create_conn(self):
conn = sqlite3.connect(self.__path, check_same_thread=False)
self.__queue_conn.put(conn)
def __close(self, cursor, conn):
if cursor is not None:
cursor.close()
if conn is not None:
cursor.close()
self.__create_conn()
def execute_query(self, sql, params):
conn = self.__queue_conn.get()
cursor = conn.cursor()
value = None
try:
records = None
if not params is None:
records = cursor.execute(sql, params).fetchall()
else:
records = cursor.execute(sql).fetchall()
field = [i[0] for i in cursor.description]
value = [dict(zip(field, i)) for i in records]
finally:
self.__close(cursor, conn)
return value
def executescript(self, sql):
conn = self.__queue_conn.get()
cursor = conn.cursor()
try:
cursor.executescript(sql)
conn.mit()
except Exception as e:
conn.rollback()
raise
finally:
self.__close(cursor, conn)
def execute_update(self, sql, params):
return self.execute_update_many([sql], [params])
def execute_update_many(self, sql_list, params_list):
conn = self.__queue_conn.get()
cursor = conn.cursor()
count = 0
try:
for index in range(len(sql_list)):
sql = sql_list[index]
params = params_list[index]
if not params is None:
count += cursor.execute(sql, params).rowcount
else:
count += cursor.execute(sql).rowcount
conn.mit()
except Exception as e:
conn.rollback()
raise
finally:
self.__close(cursor, conn)
return count
'''
example:
one = SQLiteUtil('xxx.sqlite')
rst = one.execute_query('select * from website', None)
for line in rst:
print(line.get('id'), line.get('url'), line.get('content'))
print(one.execute_update('update website set content = \'2222222\' where id = ?', ('1',)))
print(one.execute_update('update website set content = \'2222222\' where id = \'1\'', None))
print('update many')
count = one.execute_update_many(
[
'update website set content = \'一\' where id = \'1\'',
'update website set content = \'二\' where id = \'2\'',
'update website set content = 1 where id = \'3\''
],
[None, None, None]
)
print('count:', count)
'''
多执行绪是并发还是并行
程序和执行绪都是由作业系统所体会的程式执行的基本单元，系统利用该基本单元实现系统对应用的并发性。程序和执行绪的区别在于：
简而言之,一个程式至少有一个程序,一个程序至少有一个执行绪.
也就是说一个程序可以有很多执行绪。
“并行”是指无论从微观还是巨集观，二者都是一起执行的，就好像两个人各拿一把铁锨在挖坑，一小时后，每人一个大坑。
高并发实时系统涉及到多执行绪处理，这样合理么
你的这个问题这么久没人回答，我估计是因为大家觉得有点宽泛。我仅针对你提到的点解释一下。
要产生并发的效果，自然考虑的是多执行绪，甚至多程序。在并发的情况下，同步问题是一个常见的，或者在大多数情况都需要考虑的问题。而不是并发处理的一个方法。同步最简单直接的方式就是加锁。当然，根据你的情况不同还可能有多种的处理方式。这个需要具体问题具体分析。不知道能否解开你的疑惑。
django的异步请求非阻塞是怎么实现的
你应该是使用了Django自己的开发服务器跑的例子，在Django关于manage.py的文档中写道：
--nothreading
The development server is multithreaded by default. Use the --nothreading option to disable the use of threading in the development server.
也就是说，默认情况下你使用./manage.py runserver会开启多个线程对HTTP请求进行伺服，所以第二个请求进来时虽然第一个请求仍在sleep，但已经新开了一个线程进行响应处理，看起来像是“非阻塞”的工作模式，其实质是多线程而非单线程，想禁用这一行为也已经给出了答案，加上--nothreading参数：./manage.py runserver --nothreading即可。
uwsgi加django是阻塞的吗
当然是阻塞的，uwsgi可以fork出子进程，但是也是有上限的。
一个子进程同一时间只能处理一个请求。
Django中怎么使用django-celery完成异步任务
许多Django应用需要执行异步任务, 以便不耽误http request的执行. 我们也可以选择许多方法来完成异步任务, 使用Celery是一个比较好的选择, 因为Celery
有着大量的社区支持, 能够完美的扩展, 和Django结合的也很好. Celery不仅能在Django中使用, 还能在其他地方被大量的使用. 因此一旦学会使用Celery, 我
们可以很方便的在其他项目中使用它.
1. Celery版本
本篇博文主要针对Celery 3.0.x. 早期版本的Celery可能有细微的差别.
2. Celery介绍
Celery的主要用处是执行异步任务, 可以选择延期或定时执行功能. 为什么需要执行异步任务呢?
第一, 假设用户正发起一个request, 并等待request完成后返回. 在这一request后面的view功能中, 我们可能需要执行一段花费很长时间的程序任务, 这一时间
可能远远大于用户能忍受的范围. 当这一任务并不需要立刻执行时, 我们便可以使用Celery在后台执行, 而不影响用户浏览网页. 当有任务需要访问远程服务器完
成时, 我们往往都无法确定需要花费的时间.
第二则是定期执行某些任务. 比如每小时需要检查一下天气预报, 然后将数据储存到数据库中. 我们可以编写这一任务, 然后让Celery每小时执行一次. 这样我们
的web应用便能获取最新的天气预报信息.
我们这里所讲的任务task, 就是一个Python功能(function). 定期执行一个任务可以被认为是延时执行该功能. 我们可以使用Celery延迟5分钟调用function
task1, 并传入参数(1, 2, 3). 或者我们也可以每天午夜运行该function.
我们偏向于将Celery放入项目中, 便于task访问统一数据库和Django设置.
当task准备运行时, Celery会将其放入列队queue中. queue中储存着可以运行的task的list. 我们可以使用多个queue, 但为了简单, 这里我们只使用一个.
将任务task放入queue就像加入todo list一样. 为了使task运行, 我们还需要在其他线程中运行的苦工worker. worker实时观察着代运行的task, 并逐一运行这
些task. 你可以使用多个worker, 通常他们位于不同服务器上. 同样为了简单起见, 我们这只是用一个worker.
我们稍后会讨论queue, worker和另外一个十分重要的进程, 接下来我们来动动手:
3. 安装Celery
我们可以使用pip在vietualenv中安装:
pip install django-celery
4. Django设置
我们暂时使用django runserver来启动celery. 而Celery代理人(broker), 我们使用Django database broker implementation. 现在我们只需要知道Celery
需要broker, 使用django自身便可以充当broker. (但在部署时, 我们最好使用更稳定和高效的broker, 例如Redis.)
在settings.py中:
import djcelery
djcelery.setup_loader()
BROKER_URL = 'django://'
...
INSTALLED_APPS = (
...
'djcelery',
'kombu.transport.django',
...
)
第一二项是必须的, 第三项则告诉Celery使用Django项目作为broker.
在INSTALLED_APPS中添加的djcelery是必须的. kombu.transport.django则是基于Django的broker
最后创建Celery所需的数据表, 如果使用South作为数据迁移工具, 则运行:
python manage.py migrate
否则运行: (Django 1.6或Django 1.7都可以)
python manage.py syncdb
5. 创建一个task
正如前面所说的, 一个task就是一个Pyhton function. 但Celery需要知道这一function是task, 因此我们可以使用celery自带的装饰器decorator: @task. 在
django app目录中创建taske.py:
from celery import task
@task()
def add(x, y):
return x + y
当settings.py中的djcelery.setup_loader()运行时, Celery便会查看所有INSTALLED_APPS中app目录中的tasks.py文件, 找到标记为task的function, 并
将它们注册为celery task.
将function标注为task并不会妨碍他们的正常执行. 你还是可以像平时那样调用它: z = add(1, 2).
6. 执行task
让我们以一个简单的例子作为开始. 例如我们希望在用户发出request后异步执行该task, 马上返回response, 从而不阻塞该request, 使用户有一个流畅的访问
过程. 那么, 我们可以使用.delay, 例如在在views.py的一个view中:
from myapp.tasks import add
...
add.delay(2, 2)
...
Celery会将task加入到queue中, 并马上返回. 而在一旁待命的worker看到该task后, 便会按照设定执行它, 并将他从queue中移除. 而worker则会执行以下代
码:
import myapp.tasks.add
myapp.tasks.add(2, 2)
7. 关于import
这里需要注意的是, 在impprt task时, 需要保持一致. 因为在执行djcelery.setup_loader()时, task是以INSTALLED_APPS中的app名,
加.tasks.function_name注册的, 如果我们由于python path不同而使用不同的引用方式时(例如在tasks.py中使用from myproject.myapp.tasks import
add形式), Celery将无法得知这是同一task, 因此可能会引起奇怪的bug.
8. 测试
a. 启动worker
正如之前说到的, 我们需要worker来执行task. 以下是在开发环境中的如何启动worker:
首先启动terminal, 如同开发django项目一样, 激活virtualenv, 切换到django项目目录. 然后启动django自带web服务器: python manage.py runserver.
然后启动worker:
python manage.py celery worker --loglevel=info
此时, worker将会在该terminal中运行, 并显示输出结果.
b. 启动task
打开新的terminal, 激活virtualenv, 并切换到django项目目录:
$ python manage.py shell
from myapp.tasks import add
add.delay(2, 2)
此时, 你可以在worker窗口中看到worker执行该task:
[2014-10-07 08:47:08,076: INFO/MainProcess] Got task from broker: myapp.tasks.add[e080e047-b2a2-43a7-af74-d7d9d98b02fc]
[2014-10-07 08:47:08,299: INFO/MainProcess] Task myapp.tasks.add[e080e047-b2a2-43a7-af74-d7d9d98b02fc] succeeded in 0.183349132538s: 4
9. 另一个例子
下面我们来看一个更为真实的例子, 在views.py和tasks.py中:
# views.py
from myapp.tasks import do_something_with_form_data
def view(request):
form = SomeForm(request.POST)
if form.is_valid():
data = form.cleaned_data
# Schedule a task to process the data later
do_something_with_form_data.delay(data)
return render_to_response(...)
# tasks.py
@task
def do_something_with_form_data(data):
call_slow_web_service(data['user'], data['text'], ...)
10. 调试
由于Celery的运行需要启动多个部件, 我们可能会漏掉一两个. 所以我们建议:
使用最简单的设置
使用python debug和logging功能显示当前的进程
11. Eager模式
如果在settings.py设置:
CELERY_ALWAYS_EAGER = True
那么Celery便以eager模式运行, 则task便不需要加delay运行:
# 若启用eager模式, 则以下两行代码相同
add.delay(2, 2)
add(2, 2)
12. 查看queue
因为我们使用了django作为broker, queue储存在django的数据库中. 这就意味着我们可以通过django admin查看该queue:
# admin.py
from django.contrib import admin
from kombu.transport.django import models as kombu_models
admin.site.register(kombu_models.Message)
13. 检查结果
每次运行异步task后, Celery都会返回AsyncResult对象作为结果. 你可以将其保存, 然后在将来查看该task是否运行成功和返回结果:
# views.py
result = add.delay(2, 2)
...
if result.ready():
print "Task has run"
if result.successful():
print "Result was: %s" % result.result
else:
if isinstance(result.result, Exception):
print "Task failed due to raising an exception"
raise result.result
else:
print "Task failed without raising exception"
else:
print "Task has not yet run"
14. 定期任务
还有一种Celery的常用模式便是执行定期任务. 执行定期任务时, Celery会通过celerybeat进程来完成. Celerybeat会保持运行, 一旦到了某一定期任务需要执
行时, Celerybeat便将其加入到queue中. 不像worker进程, Celerybeat只有需要一个即可.
启动Celerybeat:
python manage.py celery beat
使Celery运行定期任务的方式有很多种, 我们先看第一种, 将定期任务储存在django数据库中. 即使是在django和celery都运行的状态, 这一方式也可以让我们
方便的修改定期任务. 我们只需要设置settings.py中的一项便能开启这一方式:
# settings.py
CELERYBEAT_SCHEDULER = 'djcelery.schedulers.DatabaseScheduler'
结语：以上就是首席CTO笔记为大家整理的关于django如何处理阻塞的全部内容了，感谢您花时间阅读本站内容，希望对您有所帮助，更多关于django如何处理阻塞的相关内容别忘了在本站进行查找喔。