让天下没有难学的技术
作者：Adrianos Dadis　译者：买蓉（sky.）　校对：方腾飞
在高负载多线程应用中性能是非常重要的。为了达到更好的性能，开发者必须意识到并发的重要性。当我们需要使用并发时， 常常有一个资源必须被两个或多个线程共享。
在这种情况下，就存在一个，也就是其中一个线程可以得到锁（锁与特定资源绑定），其他想要得到锁的线程会被阻塞。这个同步机制的实现是有代价的，为了向你提供一个好用的同步模型，JVM和操作系统都要消耗资源。有三个最重要的因素使并发的实现会消耗大量资源，它们是：
上下文切换
(4 votes, average: 4.00 out of 5)
Loading...
感谢［］同学的投稿，投稿可将文章发送到
类锁和对象锁是否会冲突？对象锁和私有锁是否会冲突？通过实例来进行说明。
一、相关约定
为了明确后文的描述，先对本文涉及到的锁的相关定义作如下约定：
1. 类锁：在代码中的方法上加了static和synchronized的锁，或者synchronized(xxx.class）的代码段，如下文中的increament()；
2.对象锁：在代码中的方法上加了synchronized的锁，或者synchronized(this）的代码段，如下文中的synOnMethod()和synInMethod()；
3.私有锁：在类内部声明一个私有属性如private Object lock，在需要加锁的代码段synchronized(lock），如下文中的synMethodWithObj()。
(3 votes, average: 3.33 out of 5)
Loading...
作者：山鸡
锁作为并发共享数据，保证一致性的工具，在JAVA平台有多种实现(如 synchronized 和 ReentrantLock等等 ) 。这些已经写好提供的锁为我们开发提供了便利，但是锁的具体性质以及类型却很少被提及。本系列文章将分析JAVA下常见的锁名称以及特性，为大家答疑解惑。
(2 votes, average: 4.50 out of 5)
Loading...
作者：山鸡
锁作为并发共享数据，保证一致性的工具，在JAVA平台有多种实现(如 synchronized 和 ReentrantLock等等 ) 。这些已经写好提供的锁为我们开发提供了便利，但是锁的具体性质以及类型却很少被提及。本系列文章将分析JAVA中常见的锁以及其特性，为大家答疑解惑。
(6 votes, average: 3.50 out of 5)
Loading...
作者：Pedro Ramalhete，译者：周可人，校对：梁海舰
Tick lock是mutual lock的一种简单实现：
它是由John Mellor-Crummey和Michael Scott在1991年提出的（pdf中2.2节），感谢C++11和C11中新的内存模型，我们可以对单个变量进行具有屏障或者不具有屏障的原子操作。当屏障没有使用，只有原子性保证时，我们称之为“relaxed atomic”：
注意在C11/C++11内存模型中，一个原子变量并不具有内在的“顺序一致性”或者“relaxed”性质，然而我们可以在每次访问的时选择它的行为。
原子修饰符只能保证原子性，即这个变量会被单步读或写。其他语言，如Java和Scala则不同，它们可以保证几乎所有的原生类型提供原子性保证，从而表现为“relaxed atomic”。并且，所有被声明为顺序一致性的变量可以在整个程序中保持性质（除非在Java中使用sun.misc.unsafe）。尽管这个细微的差异可能看起来并不重要，但是当我们的目标是从同步或是并发算法中挖掘最大性能时，就需要关注这个差异了。
(2 votes, average: 3.00 out of 5)
Loading...
译者：曹姚君 校对： 方腾飞
上周在由通过组织的开放空间会议(unconference)上，我参加一个新的java规范
的审查会议。StampedLock 是为了解决多个readers 并发访问共享状态时，系统出现的内存地址竞争问题。在设计上通过使用乐观的读操作，StampedLock 比更加高效；
在会议期间，我突然意思到两点：
第一、我想是时候该去回顾java中锁的实现的现状。
第二、虽然StampedLock 看上去是JDK很好的补充，但是它视乎忽略了一个事实，即在多个reader的场景里，无锁的算法通常是更好的解决方案。
(4 votes, average: 4.25 out of 5)
Loading...
声明：本文是《 》的第八章， 作者： Javier Fernández González 译者：郑玉婷
校对：方腾飞
监控Lock接口
Lock 接口是Java 并发 API提供的最基本的机制来同步代码块。它允许定义临界区。临界区是代码块可以共享资源，但是不能被多个线程同时执行。此机制是通过Lock 接口和 ReentrantLock 类实现的。
在这个指南，你将学习从Lock对象可以获取的信息和如何获取这些信息。
(1 votes, average: 5.00 out of 5)
Loading...
声明：本文是《 》的第七章，作者： Javier Fernández González
译者：许巧辉
实现一个自定义的Lock类
锁是Java并发API提供的基本同步机制之一。它允许程序员保护代码的临界区，所以，在某个时刻只有一个线程能执行这个代码块。它提供以下两种操作：
lock()：当你想要访问一个临界区时，调用这个方法。如果有其他线程正在运行这个临界区，其他线程将阻塞，直到它们被这个锁唤醒，从而获取这个临界区的访问。
unlock()：你在临界区的尾部调用这个方法，允许其他线程访问这个临界区。
在Java并发API中，锁是在Lock接口及其一些实现类中声明的，比如ReentrantLock类。
在这个指南中，你将学习如何实现你自己的Lock对象，它将实现一个实现了Lock接口并可用来保护临界区的类。
(2 votes, average: 4.50 out of 5)
Loading...
声明：本文是《 》的第二章，作者： Javier Fernández González
译者：许巧辉 校对：方腾飞
在Lock中使用多个条件
一个锁可能伴随着多个条件。这些条件声明在Condition接口中。 这些条件的目的是允许线程拥有锁的控制并且检查条件是否为true，如果是false，那么线程将被阻塞，直到其他线程唤醒它们。Condition接口提供一种机制，阻塞一个线程和唤醒一个被阻塞的线程。
在并发编程中，生产者与消费者是经典的问题。我们有一个数据缓冲区，一个或多个数据生产者往缓冲区存储数据，一个或多个数据消费者从缓冲区中取出数据，正如在这一章中前面所解释的一样。
在这个指南中，你将学习如何通过使用锁和条件来实现生产者与消费者问题。
(1 votes, average: 5.00 out of 5)
Loading...
声明：本文是《 》的第二章，作者： Javier Fernández González
译者：许巧辉 校对：方腾飞
修改Lock的公平性
在ReentrantLock类和 ReentrantReadWriteLock类的构造器中，允许一个名为fair的boolean类型参数，它允许你来控制这些类的行为。默认值为 false，这将启用非公平模式。在这个模式中，当有多个线程正在等待一把锁（ReentrantLock或者 ReentrantReadWriteLock），这个锁必须选择它们中间的一个来获得进入临界区，选择任意一个是没有任何标准的。true值将开启公平 模式。在这个模式中，当有多个线程正在等待一把锁（ReentrantLock或者ReentrantReadWriteLock），这个锁必须选择它们 中间的一个来获得进入临界区，它将选择等待时间最长的线程。考虑到之前解释的行为只是使用lock()和unlock()方法。由于tryLock()方 法并不会使线程进入睡眠，即使Lock接口正在被使用，这个公平属性并不会影响它的功能。
在这个指南中，我们将修改使用Lock同步代码块食谱示例来使用这个属性，并且观察公平与非公平模式之间的差别。
(2 votes, average: 5.00 out of 5)
Loading...
声明：本文是《 》的第二章，作者： Javier Fernández González
译者：许巧辉
使用读/写锁同步数据访问
锁所提供的最重要的改进之一就是ReadWriteLock接口和唯一 一个实现它的ReentrantReadWriteLock类。这个类提供两把锁，一把用于读操作和一把用于写操作。同时可以有多个线程执行读操作，但只有一个线程可以执行写操作。当一个线程正在执行一个写操作，不可能有任何线程执行读操作。
在这个指南中，你将会学习如何使用ReadWriteLock接口实现一个程序，使用它来控制访问一个存储两个产品价格的对象。
(3 votes, average: 3.33 out of 5)
Loading...
声明：本文是《 》的第二章，作者： Javier Fernández González
译者：许巧辉 校对：方腾飞
使用Lock同步代码块
Java提供另外的机制用来同步代码块。它比synchronized关键字更加强大、灵活。它是基于Lock接口和实现它的类（如ReentrantLock）。这种机制有如下优势：
它允许以一种更灵活的方式来构建synchronized块。使用synchronized关键字，你必须以结构化方式得到释放synchronized代码块的控制权。Lock接口允许你获得更复杂的结构来实现你的临界区。
Lock 接口比synchronized关键字提供更多额外的功能。新功能之一是实现的tryLock()方法。这种方法试图获取锁的控制权并且如果它不能获取该锁，是因为其他线程在使用这个锁，它将返回这个锁。使用synchronized关键字，当线程A试图执行synchronized代码块，如果线程B正在执行它，那么线程A将阻塞直到线程B执行完synchronized代码块。使用锁，你可以执行tryLock()方法，这个方法返回一个 Boolean值表示，是否有其他线程正在运行这个锁所保护的代码。
当有多个读者和一个写者时，Lock接口允许读写操作分离。
Lock接口比synchronized关键字提供更好的性能。
在这个指南中，你将学习如何通过锁来同步代码块和通过Lock接口及其实现者ReentrantLock类来创建临界区，实现一个程序来模拟打印队列。
(4 votes, average: 4.00 out of 5)
Loading...
作者：paul
译者：谢宝友，鲁阳，陈渝
在过去几十年并发研究领域的出版物中，锁总是扮演着坏人的角色，锁背负的指控包括引起死锁、锁封护（luyang注：lock convoying，多个同优先级的线程重复竞争同一把锁，此时大量虽然被唤醒而得不到锁的线程被迫进行调度切换，这种频繁的调度切换相当影响系统性能）、饥饿、不公平、data races以及其他许多并发带来的罪孽。有趣的是，在共享内存并行软件中真正承担重担的是——你猜对了——锁。
图1.1：锁：坏人还是懒汉？
(2 votes, average: 1.00 out of 5)
Loading...
译者：张坤等
（未翻译）
(35 votes, average: 4.43 out of 5)
Loading...
校对：方腾飞
如果一个线程因为CPU时间全部被其他线程抢走而得不到CPU运行时间，这种状态被称之为“饥饿”。而该线程被“饥饿致死”正是因为它得不到CPU运行时间的机会。解决饥饿的方案被称之为“公平性” – 即所有线程均能公平地获得运行机会。
下面是本文讨论的主题：
1. Java中导致饥饿的原因：
高优先级线程吞噬所有的低优先级线程的CPU时间。
线程被永久堵塞在一个等待进入同步块的状态。
线程在等待一个本身也处于永久等待完成的对象(比如调用这个对象的wait方法)。
2. 在Java中实现公平性方案，需要:
使用锁，而不是同步块。
注意性能方面。
(7 votes, average: 4.57 out of 5)
Loading...
作者：Jakob Jenkov
译者：余绍亮
校对：丁一
嵌套管程锁死类似于死锁， 下面是一个嵌套管程锁死的场景：
线程1获得A对象的锁。
线程1获得对象B的锁（同时持有对象A的锁）。
线程1决定等待另一个线程的信号再继续。
线程1调用B.wait()，从而释放了B对象上的锁，但仍然持有对象A的锁。
线程2需要同时持有对象A和对象B的锁，才能向线程1发信号。
线程2无法获得对象A上的锁，因为对象A上的锁当前正被线程1持有。
线程2一直被阻塞，等待线程1释放对象A上的锁。
线程1一直阻塞，等待线程2的信号，因此，不会释放对象A上的锁，
而线程2需要对象A上的锁才能给线程1发信号……
(3 votes, average: 5.00 out of 5)
Loading...
作者：Jakob Jenkov 译者：刘晓日 校对：丁一
重入锁死与和非常相似。和两篇文章中都有涉及到重入锁死的问题。
当一个线程重新获取，或其他不可重入的同步器时，就可能发生重入锁死。可重入的意思是线程可以重复获得它已经持有的锁。Java的synchronized块是可重入的。因此下面的代码是没问题的：
（译者注：这里提到的锁都是指的不可重入的锁实现，并不是Java类库中的Lock与ReadWriteLock类）
(4 votes, average: 5.00 out of 5)
Loading...
本文属于作者原创，原文发表于InfoQ：
锁的释放-获取建立的happens before 关系
锁是java并发编程中最重要的同步机制。锁除了让临界区互斥执行外，还可以让释放锁的线程向获取同一个锁的线程发送消息。下面是锁释放-获取的示例代码：
class MonitorExample {
int a = 0;
public synchronized void writer() {
public synchronized void reader() {
假设线程A执行writer()方法，随后线程B执行reader()方法。根据happens before规则，这个过程包含的happens before 关系可以分为两类：
根据程序次序规则，1 happens before 2, 2 happens before 3; 4 happens before 5, 5 happens before 6。
根据监视器锁规则，3 happens before 4。
根据happens before 的传递性，2 happens before 5。
(4 votes, average: 5.00 out of 5)
Loading...
作者：Jakob Jenkov 译者：微凉 校对：丁一
相比里Lock实现，读写锁更复杂一些。假设你的程序中涉及到对一些共享资源的读和写操作，且写操作没有读操作那么频繁。在没有写操作的时候，两个线程同时读一个资源没有任何问题，所以应该允许多个线程能在同时读取共享资源。但是如果有一个线程想去写这些共享资源，就不应该再有其它线程对该资源进行读或写（译者注：也就是说：读-读能共存，读-写不能共存，写-写不能共存）。这就需要一个读/写锁来解决这个问题。
Java5在java.util.concurrent包中已经包含了读写锁。尽管如此，我们还是应该了解其实现背后的原理。
以下是本文的主题
(3 votes, average: 5.00 out of 5)
Loading...
作者：Jakob Jenkov 译者： 校对：丁一
锁像synchronized同步块一样，是一种线程同步机制，但比Java中的synchronized同步块更复杂。因为锁（以及其它更高级的线程同步机制）是由synchronized同步块的方式实现的，所以我们还不能完全摆脱synchronized关键字（译者注：这说的是Java 5之前的情况）。
自Java 5开始，java.util.concurrent.locks包中包含了一些锁的实现，因此你不用去实现自己的锁了。但是你仍然需要去了解怎样使用这些锁，且了解这些实现背后的理论也是很有用处的。可以参考我对的介绍，以了解更多关于锁的信息。
以下是本文所涵盖的主题：
(13 votes, average: 4.92 out of 5)
Loading...1、ReentrantLock 拥有Synchronized相同的并发性和内存语义，此外还多了 锁投票，定时锁等候和中断锁等候
线程A和B都要获取对象O的锁定，假设A获取了对象O锁，B将等待A释放对O的锁定，
如果使用 synchronized ，如果A不释放，B将一直等下去，不能被中断
如果 使用ReentrantLock，如果A不释放，可以使B在等待了足够长的时间以后，中断等待，而干别的事情
ReentrantLock获取锁定与三种方式：
lock(), 如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁
b) tryLock(), 如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false；
c)tryLock(long timeout,TimeUnit unit)，
如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false；
d) lockInterruptibly:如果获取了锁定立即返回，如果没有获取锁定，当前线程处于休眠状态，直到或者锁定，或者当前线程被别的线程中断 2、synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会自动释放锁定，但是使用Lock则不行，lock是通过代码实现的，要保证锁定一定会被释放，就必须将unLock()放到finally{}中 3、在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态；
5.0的多线程任务包对于同步的性能方面有了很大的改进，在原有synchronized关键字的基础上，又增加了ReentrantLock，以及各种Atomic类。了解其性能的优劣程度，有助与我们在特定的情形下做出正确的选择。
总体的结论先摆出来：
synchronized： 在资源竞争不是很激烈的情况下，偶尔会有同步的情形下，synchronized是很合适的。原因在于，编译程序通常会尽可能的进行优化synchronize，另外可读性非常好，不管用没用过5.0多线程包的程序员都能理解。
ReentrantLock: ReentrantLock提供了多样化的同步，比如有时间限制的同步，可以被Interrupt的同步（synchronized的同步是不能Interrupt的）等。在资源竞争不激烈的情形下，性能稍微比synchronized差点点。但是当同步非常激烈的时候，synchronized的性能一下子能下降好几十倍。而ReentrantLock确还能维持常态。
Atomic: 和上面的类似，不激烈情况下，性能比synchronized略逊，而激烈的时候，也能维持常态。激烈的时候，Atomic的性能会优于ReentrantLock一倍左右。但是其有一个缺点，就是只能同步一个值，一段代码中只能出现一个Atomic的变量，多于一个同步无效。因为他不能在多个Atomic之间同步。
所以，我们写同步的时候，优先考虑synchronized，如果有特殊需要，再进一步优化。ReentrantLock和Atomic如果用的不好，不仅不能提高性能，还可能带来灾难。
先贴测试结果：再贴代码（Atomic测试代码不准确，一个同步中只能有1个Actomic，这里用了2个，但是这里的测试只看速度） ========================== round:100000 thread:5 Sync =
========================== round:200000 thread:10 Sync =
========================== round:300000 thread:15 Sync =
========================== round:400000 thread:20 Sync =
========================== round:500000 thread:25 Sync =
package test.
import static java.lang.System.
import java.util.R
import java.util.concurrent.BrokenBarrierE
import java.util.concurrent.CyclicB
import java.util.concurrent.ExecutorS
import java.util.concurrent.E
import java.util.concurrent.atomic.AtomicI
import java.util.concurrent.atomic.AtomicL
import java.util.concurrent.locks.ReentrantL
public class TestSyncMethods {
public static void test(int round,int threadNum,CyclicBarrier cyclicBarrier){
new SyncTest("Sync",round,threadNum,cyclicBarrier).testTime();
new LockTest("Lock",round,threadNum,cyclicBarrier).testTime();
new AtomicTest("Atom",round,threadNum,cyclicBarrier).testTime();
public static void main(String args[]){
for(int i=0;i&5;i++){
int round=100000*(i+1);
int threadNum=5*(i+1);
CyclicBarrier cb=new CyclicBarrier(threadNum*2+1);
out.println("==========================");
out.println("round:"+round+" thread:"+threadNum);
test(round,threadNum,cb);
class SyncTest extends TestTemplate{
public SyncTest(String _id,int _round,int _threadNum,CyclicBarrier _cb){
super( _id, _round, _threadNum, _cb);
* synchronized关键字不在方法签名里面，所以不涉及重载问题
synchronized long
getValue() {
return super.countV
synchronized void
sumValue() {
super.countValue+=preInit[index++%round];
class LockTest extends TestTemplate{
ReentrantLock lock=new ReentrantLock();
public LockTest(String _id,int _round,int _threadNum,CyclicBarrier _cb){
super( _id, _round, _threadNum, _cb);
* synchronized关键字不在方法签名里面，所以不涉及重载问题
long getValue() {
lock.lock();
return super.countV
lock.unlock();
void sumValue() {
lock.lock();
super.countValue+=preInit[index++%round];
lock.unlock();
class AtomicTest extends TestTemplate{
public AtomicTest(String _id,int _round,int _threadNum,CyclicBarrier _cb){
super( _id, _round, _threadNum, _cb);
* synchronized关键字不在方法签名里面，所以不涉及重载问题
getValue() {
return super.countValueAtmoic.get();
sumValue() {
super.countValueAtmoic.addAndGet(super.preInit[indexAtomic.get()%round]);
abstract class TestTemplate{
private int threadN
protected long countV
protected AtomicLong countValueAtmoic=new AtomicLong(0);
protected int[] preI
protected AtomicInteger indexAtomic=new AtomicInteger(0);
Random r=new Random(47);
//任务栅栏，同批任务，先到达wait的任务挂起，一直等到全部任务到达制定的wait地点后，才能全部唤醒，继续执行
private CyclicB
public TestTemplate(String _id,int _round,int _threadNum,CyclicBarrier _cb){
this.round=_
this.threadNum=_threadN
preInit=new int[round];
for(int i=0;i&preInit.i++){
preInit[i]=r.nextInt(100);
abstract void sumValue();
* 对long的操作是非原子的，原子操作只针对32位
* long是64位，底层操作的时候分2个32位读写，因此不是线程安全
abstract long getValue();
public void testTime(){
ExecutorService se=Executors.newCachedThreadPool();
long start=System.nanoTime();
//同时开启2*ThreadNum个数的读写线程
for(int i=0;i&threadNi++){
se.execute(new Runnable(){
public void run() {
for(int i=0;i&i++){
sumValue();
//每个线程执行完同步方法后就等待
cb.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (BrokenBarrierException e) {
// TODO Auto-generated catch block
e.printStackTrace();
se.execute(new Runnable(){
public void run() {
getValue();
//每个线程执行完同步方法后就等待
cb.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (BrokenBarrierException e) {
// TODO Auto-generated catch block
e.printStackTrace();
//当前统计线程也wait,所以CyclicBarrier的初始值是threadNum*2+1
cb.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (BrokenBarrierException e) {
// TODO Auto-generated catch block
e.printStackTrace();
//所有线程执行完成之后，才会跑到这一步
long duration=System.nanoTime()-
out.println(id+" = "+duration);
/blog/1112535
/blog/826162
阅读(...) 评论()0&&parseInt(document.getElementById('custompage').value)页&&1&&parseInt(document.getElementById('custompage').value)楼&&
回复：9 &查看：2916 &
问题来了。无钥匙进入问题求解。按lock不能锁车
财产: 1967 爱卡币
来自: 浙江省|衢州市
问题来了。无钥匙进入问题求解。按lock不能锁车
不能开门，按lock 不能锁车 车会报警。
760) {this.resized= this.width=760; this.alt='Click here to open new window';}" onmouseover="if(this.width>760) {this.resized= this.width=760; this.style.cursor='hand'; this.alt='Click here to open new window';}" onclick="if(!this.resized) {} else {window.open('.cn/attachments/a/day_bbc67dd5DnKclbztdJa.jpg');}" onmousewheel="return imgzoom(this);" alt="" />
★★★★★★衢州宝马车主群★★★★★&&
衢州人数最多最活跃的宝马车主群
[每日热点]:
财产: 10768 爱卡币
来自: 辽宁省|鞍山市
[每日热点]:
财产: 1206 爱卡币
来自: 广东省|深圳市
[每日热点]:
财产: 9097 爱卡币
来自: 河南省|郑州市
共获得爱卡币
车没熄火？车里还有一把钥匙？一般来说这两种情况车是锁不上的
[每日热点]:
财产: 3409 爱卡币
来自: 广东省|清远市
共获得爱卡币
中东4000，智能钥匙锁不上车有几种情况：钥匙在车内、没熄火、没启动但启动按钮电源在1或2档、N档熄火。基本就这些
[每日热点]:
财产: 1967 爱卡币
来自: 浙江省|衢州市
中东4000，锁不上车有几种情况：钥匙在车内、没、没启动但启动按钮电源在1或2档、N档熄火。基本就这些 哎 原来是另外一把钥匙在车里没拿出来
★★★★★★衢州宝马车主群★★★★★&&
衢州人数最多最活跃的宝马车主群
[每日热点]:
财产: 1967 爱卡币
来自: 浙江省|衢州市
车没熄火？车里还有一把钥匙？一般来说这两种情况车是锁不上的 是的 车里还有个钥匙
★★★★★★衢州宝马车主群★★★★★&&
衢州人数最多最活跃的宝马车主群
[每日热点]:
财产: 10752 爱卡币
来自: 台湾省|花莲县
[每日热点]:
重回爱卡，变化很大！
财产: 580 爱卡币
来自: 山东省|青岛市
[每日热点]:
财产: 1713 爱卡币
来自: 四川省|广元市
同意5楼意见。
从现在开始~~~
[每日热点]:
回复成功，收到1个大米！
10&&parseInt(document.getElementById('custompage_down').value)页楼
相关论坛：查看: 5018|回复: 5
求救，./data/install.lock 您必须解决以上问题，安装才可以继续
windows2003 独立服务器。
按照DISCUZ 7.2的安装说明，先要安装ucenter 1.5，
这是IIS的目录设置
安装用户中心成功，点击下一步，网页就打不开了。
我再重新输入网址，看到的结果是：
安装锁定，已经安装过了，如果您确定要重新安装，请到服务器上删除
./data/install.lock
您必须解决以上问题，安装才可以继续
手动删除install.lock 好几次都没用。
有谁能指点下，我的问题是处在哪？
在线等。。。
(43.19 KB, 下载次数: 3)
17:06 上传
(29.15 KB, 下载次数: 20)
17:08 上传
(29.06 KB, 下载次数: 14)
17:09 上传
(11.83 KB, 下载次数: 6)
17:09 上传
组图打开中，请稍候......
iis的安装路径不要加入install
已经安装过了呀
路径根本不存在&&这是设置目录
因为你已经安装过了。所以这样提示。
& &我现在把IIS的路径改成了D:\ucenter
三、安装过程
上传完毕后，开始在浏览器中安装 Discuz! 7.2 ，登录 UCenter 1.5 =& 应用管理 =& 添加新应用 =& URL 安装 (推荐)：
用我的网站域名替换“应用程序安装地址”中的 “http://domainname”
点安装了，却出现了 ，./data/install.lock 您必须解决以上问题，安装才可以继续
我去把，./data/install.lock&&删除了，还是不行
(45.41 KB, 下载次数: 24)
17:27 上传
(29.06 KB, 下载次数: 4)
17:27 上传
(12.03 KB, 下载次数: 25)
17:28 上传
Powered by