为什么用WHILE不能遍历输出表
一个很普通查询输出函数现在表中有10条数据
调用的时候因为要把结果转成XML所以不能在函数体里做echo
但是这样调用只能输出最后一条记录，求能在调用页面输出整表内容的方法
调用
echo main_shopactive();
函数体
function main_shopactive()
{
//商场活动查询,返回逆向排序的最后一条活动记录
$conn = mysql_connect_conn();
$sql = "SELECT * FROM wx_active order by id desc limit 0,30";
$rs = mysql_db($sql,$conn) or die('查询记录失败!');
if(mysql_num_rows($rs) > 0)
{
while($row = mysql_fetch_assoc($rs))
{
$my_active = $row['concent'];
}
}
else
{
$my_active = 'NO ACTIVE';
}
return $my_active;
}

关于生产者模式，想必大家也非常了解了，其中java实现的一个简易模型：生产者在一个固定容量的容器中加入元素，通知消费者消费，消费者消费后通知生产者生产
​	当生产的时候需要判断容器中是否已经满，为什么这个判断需要用while而不能用if呢，例如下面代码中第7行
public class MyContainer1<T> {
	final private LinkedList<T> lists = new LinkedList<>();
	final private int MAX = 10; //最多10个元素
	private int count = 0;
	
	public synchronized void put(T t) {
		while(lists.size() == MAX) { //为什么用while而不是用if？
			try {
				this.wait(); //effective java中提倡wait，while一起使用
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		lists.add(t);
		++count;
		this.notifyAll(); //通知消费者线程进行消费
	}
	
	public synchronized T get() {
		T t = null;
		while(lists.size() == 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		t = lists.removeFirst();
		count --;
		this.notifyAll(); //通知生产者进行生产
		return t;
	}
	
}

一开始我一直在疑惑，put方式不是加了synchronized吗，为什么要循环判断来防止其它线程过多添加元素？了解到了锁获取/释放的机制，终于得出了答案：
因为wait会释放锁！
结合代码第7行，当容器满了的时候，第一个线程拿到锁，进入到while块内，调用wait方法并释放了锁。第二个线程也能拿到锁，遇到wait同样会等待
这时线程1，线程2，都在wait处等待了！！，这是问题的关键
当消费者消费了1个元素，调用了notiftyAll方法，线程1和线程2都唤醒了，它们会竞争锁，假设线程1拿到了锁，这时线程2继续在锁池中阻塞。
线程1直接到执行下面的代码增加元素，增加完后容器已经满(MAX)
但是线程1执行完，会释放锁，又因为线程2此时是醒着的，它将得到线程1释放的锁，继续从wait()处往下执行。如果是if，它不作判断就直接往满的容器中加元素，造成错误。如果是while，线程2往下执行时会再次进入到while判断。因为此时容器已经满了，所以线程2，再次被wait，保证了数据的安全

多线程的情况下，单个生产者和单个消费者用if判断是否await不会出错；当有多个消费者的时候，还使用if判断是否await就会产生问题，这是因为一个生产者消费者模型的任务队列，一个消费者一次放入多个任务，然后用notifyAll通知消费者，但是并非所有被唤醒的消费者都能取到一个任务，那么队列被读空了之后的消费者肯定得继续await。如果你用if来判断，这个消费者第二次被notify的时候就不会再次判断这个条件了，如果这个时候这个消费者又一次没抢到任务，但是代码还是往下执行了，轻则空指针异常，重了干出什么事情来都说不定了。所以必须用while来检查，这样可以保证每次被唤醒都会检查一次条件。

    最近在研究wait和notify方法，发现有个地方要注意，但是网上又说得不是很明白的地方，就是经典的生产者和消费模式，使用wait和notify实现，判断list是否为空的这个为什么要用while而不能使用if呢？其实是因为当线程wait之后，又被唤醒的时候，是从wait后面开始执行，而不是又从头开始执行的，所以如果用if的话，被唤醒之后就不会在判断if中的条件，而是继续往下执行了，如果list只是添加了一个数据，而存在两个消费者被唤醒的话，就会出现溢出的问题了，因为不会在判断size是否==0就直接执行remove了。但是如果使用while的话，从wait下面继续执行，还会返回执行while的条件判断，size>0了才会执行remove操作，所以这个必须使用while，而不能使用if来作为判断。

    以下代码是一个简单的实践，参考：http://www.cnblogs.com/hapjin/p/5492645.html（做了适当的调整）

     Add类，负责添加数据：









1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24




public class Add
 {

    private String
 lock;

    public Add(String
 lock) {

        super();

        this.lock
 = lock;

    }

    public void add()
 {

        synchronized (lock)
 {

            ValueObject.list.add("anyString");

            lock.notifyAll();

        }

    }

}

public class ThreadAdd extends Thread
 {

    private Add
 p;

    public ThreadAdd(Add
 p) {

        super();

        this.p
 = p;

    }

    @Override

    public void run()
 {

        p.add();

    }

} 










    Subtract类，负责删除数据









1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39




public class Subtract
 {

    private String
 lock;

    public Subtract(String
 lock) {

        super();

        this.lock
 = lock;

    }

    public boolean check()
 {

        System.out.println("check");

        return true;

    }

    public void subtract()
 {

        try {

            synchronized (lock)
 {

                if(check()
 && ValueObject.list.size() == 0)
 {//将这里的if改成while即可保证不出现越界异常!!!!

                    System.out.println("wait
 begin ThreadName="

                            +
 Thread.currentThread().getName());

                    lock.wait();

                    System.out.println("wait  
 end ThreadName="

                            +
 Thread.currentThread().getName());

                }

                ValueObject.list.remove(0);

                System.out.println("list
 size=" +
 ValueObject.list.size());

            }

        } catch (InterruptedException
 e) {

            e.printStackTrace();

        }

    }

}

public class ThreadSubtract extends Thread
 {

    private Subtract
 r;

    public ThreadSubtract(Subtract
 r) {

        super();

        this.r
 = r;

    }

    @Override

    public void run()
 {

        r.subtract();

    }

}










    封装的List队列：


public class ValueObject {
    public static List list = new ArrayList();
} 




    测试类：





public class Run {
    public static void main(String[] args) throws InterruptedException {
        String lock = new String("");
        Add add = new Add(lock);
        Subtract subtract = new Subtract(lock);
        ThreadSubtract subtract1Thread = new ThreadSubtract(subtract);
        subtract1Thread.setName("subtract1Thread");
        subtract1Thread.start();
        ThreadSubtract subtract2Thread = new ThreadSubtract(subtract);
        subtract2Thread.setName("subtract2Thread");
        subtract2Thread.start();
        Thread.sleep(1000);
        ThreadAdd addThread = new ThreadAdd(add);
        addThread.setName("addThread");
        addThread.start();
    }
}




转载自：https://www.cnblogs.com/ismallboy/p/6785302.html