指系统能按某种顺序如（P1，P2，...，Pn），来为每个进程分配所需要的资源，直至最大需求，使每个进程都可以顺序完成。若系统不存在这样一个安全序列，则称系统处于不安全状态。

将用户信息保存至COOKIES中。
用户信息包括：UID,USERNAME,EMAIL,PASSWORD。
其中 EMAIL,PASSWORD进行可逆加密。
每次登录只须将COOKIES进行一次可逆加密和你数据库对比一次若相等则登录，否则进行正常的登录操作。
===============
PS
======================
关于cookies中是否可以存放用户信息，一直都是业界存在争议的一点。
目前我的解决方法是：
cookies中存放有关于邮箱、QQ号码、用户密码、用户名等信息均需要进行可逆加密。
如有用户信息：array("uid"=>1,"username"=>"b","password"=>"1234567","email"=>"abc@abc.com");
那么，我将uid,username,password,email等信息分别存放与cookies中，并且将username,password,email通过key(key只能自己知道和设置)进行可逆加密。当每一次需要操作的时候，我只需要$_COOKIE['password']然后将其解密还原为原始的1234567即可，然后将其进行查询匹配。若查询相同则认为该COOKIES有效，若不匹配则删除cookies。
那么，解密之后查询认证有两种方法：
1.直接连接数据库进行SQL查询，这是一种消耗性能的低效方法。select username,uid,password from xxxx where uid='xxxx',username='xxxxx' LIMIT 1;
这种方法没操作一次需要进行一次SQL查询，将大大增加性能开销。
2.将用户第一次登录查询出来的信息加密保存在cookies的同时，copy保存一份至memcached内存中，并增加标识 uid_status(可自取) 为 1 (登录状态)，每一个用户拥有一个唯一的uid_status,并且设置为长期有效。
判断是否登录的过程则更加高效和快速。
将cookies中的信息解密之后，查看uid_status的状态，若为1，直接认定该用户处于登录状态，不删除cookies信息。若为0，非登录状态，则将cookies和memcached中的用户信息进行匹配。匹配包括：password,uid,username。若其中一项不正确则删除cookies,更新uid_status状态。
以上就是我判断用户是否登录过程。
========
P.S
===========
DISCUZ！系列是采用cookies加密后直接查询数据库进行cookies有效判断的。
uc_home核心代码是：<?php 
//判断当前用户登录状态
function checkauth() {
global $_SGLOBAL, $_SC, $_SCONFIG, $_SCOOKIE, $_SN;
if($_SGLOBAL['mobile'] && $_GET['m_auth']) $_SCOOKIE['auth'] = $_GET['m_auth'];
if($_SCOOKIE['auth']) {
@list($password, $uid) = explode("\t", authcode($_SCOOKIE['auth'], 'DECODE'));
$_SGLOBAL['supe_uid'] = intval($uid);
if($password && $_SGLOBAL['supe_uid']) {
$query = $_SGLOBAL['db']->query("SELECT * FROM ".tname('session')." WHERE uid='$_SGLOBAL[supe_uid]'");
if($member = $_SGLOBAL['db']->fetch_array($query)) {
if($member['password'] == $password) {
$_SGLOBAL['supe_username'] = addslashes($member['username']);
$_SGLOBAL['session'] = $member;
} else {
$_SGLOBAL['supe_uid'] = 0;
}
} else {
$query = $_SGLOBAL['db']->query("SELECT * FROM ".tname('member')." WHERE uid='$_SGLOBAL[supe_uid]'");
if($member = $_SGLOBAL['db']->fetch_array($query)) {
if($member['password'] == $password) {
$_SGLOBAL['supe_username'] = addslashes($member['username']);
$session = array('uid' => $_SGLOBAL['supe_uid'], 'username' => $_SGLOBAL['supe_username'], 'password' => $password);
include_once(S_ROOT.'./source/function_space.php');
insertsession($session);//登录
} else {
$_SGLOBAL['supe_uid'] = 0;
}
} else {
$_SGLOBAL['supe_uid'] = 0;
}
}
}
}
if(empty($_SGLOBAL['supe_uid'])) {
clearcookie();
} else {
$_SGLOBAL['username'] = $member['username'];
if($_SGLOBAL['connect']) {
cloud_token();
}
}
}
?>

“线程安全”实际上意味着什么？
通过优锐课的学习分享，讨论了关于Java中的线程安全性意味着类的方法是原子的或静态的。 那么原子是什么，静止是什么意思呢？ 为什么在Java中没有其他类型的线程安全方法？
“原子”是什么意思？
当方法调用似乎立即生效时，该方法就是原子的。 因此，其他线程在方法调用之前或之后只能看到状态，而没有中间状态。 让我们看一下非原子方法，看看原子方法如何使类具有线程安全性。
public class UniqueIdNotAtomic {
private volatile long counter = 0;
public  long nextId() {
return counter++;
}
}
类UniqueIdNotAtomic通过使用易失性变量计数器创建唯一的ID。 我在第2行使用了volatile字段，以确保线程始终看到当前值，如此处更详细的说明。 要查看此类是否是线程安全的，我们使用以下测试：
public class TestUniqueIdNotAtomic {
private final UniqueIdNotAtomic uniqueId = new UniqueIdNotAtomic();
private long firstId;
private long secondId;
private void updateFirstId() {
firstId  = uniqueId.nextId();
}
private void updateSecondId() {
secondId = uniqueId.nextId();
}
@Test
public void testUniqueId() throws InterruptedException {
try (AllInterleavings allInterleavings =
new AllInterleavings("TestUniqueIdNotAtomic");) {
while(allInterleavings.hasNext()) {
Thread first = new Thread( () ->   { updateFirstId();  } ) ;
Thread second = new Thread( () ->  { updateSecondId();  } ) ;
first.start();
second.start();
first.join();
second.join();
assertTrue(  firstId != secondId );
}
}
}
}
为了测试计数器是否是线程安全的，我们需要在第16和17行中创建两个线程。我们启动这两个线程(第18和19行)。然后，我们等待直到两个线程都通过第20和21行结束。 在两个线程都停止之后，我们检查两个ID是否唯一，如第22行所示。
为了测试所有线程交织，我们使用来自vmlens第15行的AllInterleavings类，将完整的测试放在while循环中迭代所有线程交织。
运行测试，我们看到以下错误：
java.lang.AssertionError:
at org.junit.Assert.fail(Assert.java:91)
at org.junit.Assert.assertTrue(Assert.java:43)
发生该错误的原因是，由于操作++不是原子操作，因此两个线程可以覆盖另一个线程的结果。 我们可以在vmlens的报告中看到这一点：
在发生错误的情况下，两个线程首先并行读取变量计数器。 然后，两个都创建相同的ID。 为了解决这个问题，我们通过使用同步块使方法原子化：
private final Object LOCK = new Object();
public  long nextId() {
synchronized(LOCK) {
return counter++;
}
}
现在，该方法是原子的。 同步块可确保其他线程无法看到该方法的中间状态。
不访问共享状态的方法是自动原子的。 具有只读状态的类也是如此。 因此，无状态和不可变的类是实现线程安全类的简便方法。 他们所有的方法都是自动的。
并非原子方法的所有用法都是自动线程安全的。 将多个原子方法组合为相同的值通常会导致争用条件。 让我们看看从ConcurrentHashMap获取和放置的原子方法以了解原因。 当以前的映射不存在时，让我们使用这些方法在映射中插入一个值：
public class TestUpdateTwoAtomicMethods {
public void update(ConcurrentHashMap  map)  {
Integer result = map.get(1);
if( result == null )  {
map.put(1, 1);
}
else    {
map.put(1, result + 1 );
}
}
@Test
public void testUpdate() throws InterruptedException    {
try (AllInterleavings allInterleavings =
new AllInterleavings("TestUpdateTwoAtomicMethods");) {
while(allInterleavings.hasNext()) {
final ConcurrentHashMap  map =
new  ConcurrentHashMap();
Thread first = new Thread( () ->   { update(map);  } ) ;
Thread second = new Thread( () ->  { update(map);  } ) ;
first.start();
second.start();
first.join();
second.join();
assertEquals( 2 , map.get(1).intValue() );
}
}
}
}
该测试与先前的测试相似。 再次，我们使用两个线程来测试我们的方法是否是线程安全的(第18行和第19行)。再次，我们在两个线程完成之后测试结果是否正确(第24行)。运行测试，我们看到以下错误：
java.lang.AssertionError: expected:<2> but was:<1>
at org.junit.Assert.fail(Assert.java:91)
at org.junit.Assert.failNotEquals(Assert.java:645)
该错误的原因是，两种原子方法get和put的组合不是原子的。 因此，两个线程可以覆盖另一个线程的结果。 我们可以在vmlens的报告中看到这一点：
在发生错误的情况下，两个线程首先并行获取值。 然后，两个都创建相同的值并将其放入地图中。 要解决这种竞争状况，我们需要使用一种方法而不是两种方法。 在我们的例子中，我们可以使用单个方法而不是两个方法get和put来进行计算：
public void update() {
map.compute(1, (key, value) -> {
if (value == null) {
return 1;
}
return value + 1;
});
}
因为方法计算是原子的，所以这解决了竞争条件。 虽然对ConcurrentHashMap的相同元素进行的所有操作都是原子操作，但对整个地图(如大小)进行操作的操作都是静态的。 因此，让我们看看静态意味着什么。
“静止”是什么意思？
静态意味着当我们调用静态方法时，我们需要确保当前没有其他方法在运行。 下面的示例显示如何使用ConcurrentHashMap的静态方法大小：
ConcurrentHashMap  map =
new  ConcurrentHashMap();
Thread first  = new Thread(() -> { map.put(1,1);});
Thread second = new Thread(() -> { map.put(2,2);});
first.start();
second.start();
first.join();
second.join();
assertEquals( 2 ,  map.size());
通过等待直到所有线程都使用线程连接完成为止，当我们调用方法大小时，我们确保没有其他线程正在访问ConcurrentHashMap。
方法大小使用在java.util.concurrent.atomic.LongAdder，LongAccumulator，DoubleAdder和DoubleAccumulator类中也使用的一种机制来避免争用。 与其使用单个变量存储当前大小，不如使用数组。 不同的线程更新数组的不同部分，从而避免争用。 该算法在Striped64的Java文档中有更详细的说明。
静态类和静态方法对于收集竞争激烈的统计数据很有用。 收集数据后，可以使用一个线程来评估收集的统计信息。
为什么在Java中没有其他线程安全方法？
在理论计算机科学中，线程安全性意味着数据结构满足正确性标准。 最常用的正确性标准是可线性化的，这意味着数据结构的方法是原子的。
对于常见的数据结构，存在可证明的线性化并发数据结构，请参见Maurice Herlihy和Nir Shavit撰写的《多处理器编程的艺术》一书。 但是要使数据结构线性化，需要使用比较和交换之类的昂贵同步机制，请参阅论文《定律：无法消除并发算法中的昂贵同步》以了解更多信息。
因此，研究了其他正确性标准(例如静态)。 因此，我认为问题不在于“为什么Java中没有其他类型的线程安全方法？” 但是，Java何时将提供其他类型的线程安全性？
结论
Java中的线程安全性意味着类的方法是原子的或静态的。 当方法调用似乎立即生效时，该方法就是原子的。 静态意味着当我们调用静态方法时，我们需要确保当前没有其他方法在运行。
目前，静态方法仅用于收集统计信息，例如ConcurrentHashMap的大小。 对于所有其他用例，使用原子方法。 让我们拭目以待，未来是否会带来更多类型的线程安全方法。
文章写道这里，如有不足之处，欢迎补充评论。
如果你对java技术很感兴趣也可以一起交流学习，共同学习进步！
最近get了很多新知识，希望能帮到大家。需要详细的java架构思维导图路线也可以评论获取！

线程安全可以简单理解为一个方法或者一个实例可以在多线程环境中使用而不会出现问题。

在同一程序中运行多个线程本身不会导致问题，问题在于多个线程访问了相同的资源。如，同一内存区（变量，数组，或对象）、系统（数据库，web services等）或文件。实际上，这些问题只有在一或多个线程向这些资源做了写操作时才有可能发生，只要资源没有发生变化,多个线程读取相同的资源就是安全的。

定义：

1.无状态的一定是线程安全的。这个很好理解，因为所谓线程不安全也就是一个线程修改了状态，而另一个线程的操作依赖于这个被修改的状态。

2.只有一个状态，而且这个状态是由一个线程安全的对象维护的，那这个类也是线程安全的。比如你在数据结构里只用一个AtomicLong来作为计数器，那递增计数的操作都是线程安全的，不会漏掉任何一次计数，而如果你用普通的long做++操作则不一样，因为++操作本身涉及到取数、递增、赋值 三个操作，某个线程可能取到了另外一个线程还没来得及写回的数就会导致上一次写入丢失。

3.有多个状态的情况下，维持不变性（invariant）的所有可变（mutable）状态都用同一个锁来守护的类是线程安全的。这一段有些拗口，首先类不变性的意思是指这个类在多线程状态下能正确运行的状态，其次用锁守护的意思是所有对该状态的操作都需要获取这个锁，而用同一个锁守护的作用就是所有对这些状态的修改实际最后都是串行的，不会存在某个操作中间状态被其他操作可见，继而导致线程不安全。所以这里的关键在于如何确定不变性，可能你的类的某些状态对于类的正确运行是无关紧要的，那就不需要用和其他状态一样的锁来守护。因此我们常可以看到有的类里面会创建一个新的对象作为锁来守护某些和原类本身不变性无关的状态。

大数据培训