Memcached服务器安装、配置、使用详解

1

wget https://github.com/downloads/libevent/libevent/libevent-1.4.14b-stable.[/code]
tar
.gz

2

tar

xvzf libevent-1.4.14b-stable.

tar

.gz

3

ln

-s /usr/

local

/libevent-1.4.14b-stable /usr/

local

/libevent

4

cd

/usr/

local

/libevent

5

./configure

6

make

7

make

install

1

wget http://www.memcached.org/files/memcached-1.4.20.[/code]
tar
.gz

2

tar

xvzf memcached-1.4.20.

tar

.gz

3

ln

-s /usr/

local

/memcached-1.4.20 /usr/

local

/memcached

4

./configure --with-libevent=/usr/

local

/libevent/

5

make

6

make

install

1

/usr/local/bin/memcached -d -m 64 -I 20m -u root -l 192.168.4.86 -p 11211 -c 1024 -P /usr/local/memcached/memcached.pid

1

ps

-ef |

grep

memcached

1

kill

-9 <PID>

1

telnet 192.168.4.86 11211

01

STAT pid 22362    //memcache服务器的进程ID  www.2cto.com

02

STAT uptime 1469315    //服务器已经运行的秒数

03

STAT time 1339671194    //服务器当前的unix时间戳

04

STAT version 1.4.9    //memcache版本

05

STAT libevent 1.4.9-stable    //libevent版本

06

STAT pointer_size 64    //当前操作系统的指针大小（32位系统一般是32bit,64就是64位操作系统）

07

STAT rusage_user 3695.485200    //进程的累计用户时间

08

STAT rusage_system 14751.273465    //进程的累计系统时间

09

STAT curr_connections 69    //服务器当前存储的items数量

10

STAT total_connections 855430    //从服务器启动以后存储的items总数量

11

STAT connection_structures 74    //服务器分配的连接构造数

12

STAT reserved_fds 20    //

13

STAT cmd_get 328806688    //get命令（获取）总请求次数

14

STAT cmd_set 75441133    //set命令（保存）总请求次数  www.2cto.com

15

STAT cmd_flush 34    //flush命令请求次数

16

STAT cmd_touch 0    //touch命令请求次数

17

STAT get_hits 253547177    //总命中次数

18

STAT get_misses 75259511    //总未命中次数

19

STAT delete_misses 4    //delete命令未命中次数

20

STAT delete_hits 565730    //delete命令命中次数

21

STAT incr_misses 0    //incr命令未命中次数

22

STAT incr_hits 0    //incr命令命中次数

23

STAT decr_misses 0    //decr命令未命中次数

24

STAT decr_hits 0    //decr命令命中次数

25

STAT cas_misses 0    //cas命令未命中次数

26

STAT cas_hits 0        //cas命令命中次数

27

STAT cas_badval 0    //使用擦拭次数

28

STAT touch_hits 0    //touch命令未命中次数

29

STAT touch_misses 0    //touch命令命中次数

30

STAT auth_cmds 0    //认证命令处理的次数

31

STAT auth_errors 0    //认证失败数目

32

STAT bytes_read 545701515844        //总读取字节数（请求字节数）

33

STAT bytes_written 1649639749866    //总发送字节数（结果字节数）

34

STAT limit_maxbytes 2147483648        //分配给memcache的内存大小（字节）

35

STAT accepting_conns 1            //服务器是否达到过最大连接（0/1）

36

STAT listen_disabled_num 0    //失效的监听数

37

STAT threads 4        //当前线程数

38

STAT conn_yields 14    //连接操作主动放弃数目

39

STAT hash_power_level 16    //

40

STAT hash_bytes 524288

41

STAT hash_is_expanding 0

42

STAT expired_unfetched 30705763

43

STAT evicted_unfetched 0

44

STAT bytes 61380700    //当前存储占用的字节数

45

STAT curr_items 28786    //当前存储的数据总数

46

STAT total_items 75441133    //启动以来存储的数据总数

47

STAT evictions 0    //为获取空闲内存而删除的items数（分配给memcache的空间用满后需要删除旧的items来得到空间分配给新的items)

48

STAT reclaimed 39957976    //已过期的数据条目来存储新数据的数目

49

END

01

package

org.shirdrn.spymemcached;

02

03

import

net.spy.memcached.AddrUtil;

04

import

net.spy.memcached.BinaryConnectionFactory;

05

import

net.spy.memcached.MemcachedClient;

06

import

net.spy.memcached.internal.OperationFuture;

07

08

public

class

TestSpymemcached {

09

10

public

static

void

main(String[] args)

throws

Exception {

11

String address =

"192.168.4.86:11211"

;

12

MemcachedClient client =

new

MemcachedClient(

new

BinaryConnectionFactory(),

13

AddrUtil.getAddresses(address));

14

15

String key =

"magic_words"

;

16

int

exp =

3600

;

17

String o =

"hello"

;

18

// set

19

OperationFuture<Boolean> setFuture = client.set(key,exp,o);

20

if

(setFuture.get()) {

21

// get

22

System.out.println(client.get(key));

23

24

// append

25

client.append(key,

" the world!"

);

26

System.out.println(client.get(key));

27

28

// prepend

29

client.prepend(key,

"Stone,"

);

30

System.out.println(client.get(key));

31

32

// replace

33

o =

"This is a test for spymemcached."

;

34

OperationFuture<Boolean> replaceFuture = client.replace(key,exp,o);

35

if

(replaceFuture.get()) {

36

System.out.println(client.get(key));

37

38

// delete

39

client.delete(key);

40

System.out.println(client.get(key));

41

}

42

}

43

44

client.shutdown();

45

}

46

47

}

001

package

org.shirdrn.xmemcached;

002

003

import

java.io.File;

004

import

java.io.IOException;

005

import

java.io.Serializable;

006

import

java.net.InetSocketAddress;

007

import

java.util.Arrays;

008

import

java.util.List;

009

import

java.util.Map;

010

import

java.util.concurrent.ExecutorService;

011

import

java.util.concurrent.Executors;

012

import

java.util.concurrent.TimeoutException;

013

import

java.util.concurrent.atomic.AtomicLong;

014

015

import

net.rubyeye.xmemcached.CASOperation;

016

import

net.rubyeye.xmemcached.GetsResponse;

017

import

net.rubyeye.xmemcached.MemcachedClient;

018

import

net.rubyeye.xmemcached.XMemcachedClientBuilder;

019

import

net.rubyeye.xmemcached.command.BinaryCommandFactory;

020

import

net.rubyeye.xmemcached.exception.MemcachedException;

021

import

net.rubyeye.xmemcached.utils.AddrUtil;

022

023

public

class

UsingXMemcachedClient {

024

025

public

static

void

main(String[] args)

throws

IOException {

026

String servers =

"192.168.4.86:11211"

;

027

// build and create a client

028

XMemcachedClientBuilder builder =

new

XMemcachedClientBuilder(

029

AddrUtil.getAddresses(servers));

030

builder.setCommandFactory(

new

BinaryCommandFactory());

031

final

MemcachedClient client = builder.build();

032

033

// examples using client to operate

034

final

String key =

"ghost"

;

035

try

{

036

// add

037

client.add(key,

0

,

"Ghost wind blows!"

);

038

System.out.println(

"add & get: "

+ client.get(key));

039

040

// append

041

client.append(key,

" It's a lie."

);

042

System.out.println(

"append & get: "

+ client.get(key));

043

044

// prepend

045

client.prepend(key,

"Who's said?! "

);

046

System.out.println(

"prepend & get: "

+ client.get(key));

047

048

// replace

049

client.replace(key,

0

,

"Everything is nothing!"

);

050

System.out.println(

"replace & get: "

+ client.get(key));

051

052

// delete

053

client.delete(key);

054

System.out.println(

"delete & get: "

+ client.get(key));

055

056

// gets

057

List<String> keys = Arrays.asList(

new

String[] {

058

"key1"

,

"key2"

,

"key3"

059

});

060

for

(String k : keys) {

061

client.set(k,

3600

,

"v:"

+ System.nanoTime());

062

}

063

Map<String,GetsResponse<Object>> values = client.gets(keys);

064

for

(Map.Entry<String,GetsResponse<Object>> entry : values.entrySet()) {

065

System.out.println(

"key="

+ entry.getKey() +

",value="

+ entry.getValue().getValue());

066

}

067

068

// cas

069

final

AtomicLong seq =

new

AtomicLong(System.nanoTime());

070

ExecutorService pool = Executors.newCachedThreadPool();

071

for

(

int

i=

0

; i<

10

; i++) {

072

pool.execute(

new

Runnable() {

073

@Override

074

public

void

run() {

075

while

(

true

) {

076

CacheResulto =

new

CacheResult();

077

o.file =

new

File(

"/opt/status/servers.lst"

);

078

o.lastmodified = seq.incrementAndGet();

079

System.out.println(

"#"

+ Thread.currentThread().getId() +

"=>o: "

+ o);

080

try

{

081

client.set(key,

0

,o);

082

Thread.sleep(

100

);

083

}

catch

(TimeoutException e) {

084

// TODO Auto-generated catch block

085

e.printStackTrace();

086

}

catch

(InterruptedException e) {

087

// TODO Auto-generated catch block

088

e.printStackTrace();

089

}

catch

(MemcachedException e) {

090

// TODO Auto-generated catch block

091

e.printStackTrace();

092

}

093

}

094

}

095

});

096

}

097

Thread.sleep(

3000

);

098

for

(

int

i=

0

; i<

10

; i++) {

099

client.cas(key,

new

CASOperation<CacheResult>() {

100

@Override

101

public

int

getMaxTries() {

102

return

3

;

103

}

104

@Override

105

public

CacheResultgetNewValue(

long

arg0,CacheResultresult) {

106

CacheResultold = result;

107

CacheResultnu =

new

CacheResult();

108

nu.file = old.file;

109

nu.lastmodified = seq.incrementAndGet();

110

System.out.println(

"cas: old="

+ old +

",new="

+ nu);

111

return

result;

112

}

113

});

114

}

115

pool.shutdown();

116

117

// flush_all

118

client.flushAll();

119

120

// stats

121

List<InetSocketAddress> addresses = AddrUtil.getAddresses(servers);

122

for

(InetSocketAddress addr : addresses) {

123

Map<String,String> stats = client.stats(addr);

124

System.out.println(stats);

125

}

126

127

}

catch

(TimeoutException e) {

128

e.printStackTrace();

129

}

catch

(InterruptedException e) {

130

e.printStackTrace();

131

}

catch

(MemcachedException e) {

132

e.printStackTrace();

133

}

134

135

synchronized

(client) {

136

try

{

137

client.wait();

138

}

catch

(InterruptedException e) {

139

e.printStackTrace();

140

}

141

}

142

143

}

144

145

static

class

CacheResult

implements

Serializable {

146

private

static

final

long

serialVersionUID = 3349686173080590047L;

147

private

File file;

148

private

long

lastmodified;

149

@Override

150

public

String toString() {

151

return

"file=["

+ file +

",lastmodified="

+ lastmodified +

"]"

;

152

}

153

}

154

155

}

01

#!/usr/bin/env node

02

03

var

MemcachedClient = require(

'memcached'

);

04

05

// configure memcached client

06

var

servers = [

'192.168.4.86:11211'

];

07

var

client =

new

MemcachedClient(servers);

08

09

// access memcached servers

10

var

key =

'ghost'

;

11

12

// set

13

var

value =

'Ghost wind blows!'

;

14

client.set(key,0,value,

function

(err) {

15

var

data =

'key='

+ key +

',value='

+ value;

16

if

(err) {

17

console.error(

'Fail to set: '

+ data);

18

}

else

{

19

console.log(

'Added: '

+ data);

20

}

21

});

22

23

// get

24

var

valueGot = client.get(key,

function

(err,data) {

25

var

dataGot =

'key='

+ key +

',valueGot='

+ data;

26

if

(err) {

27

console.error(

'Fail to get: '

+ dataGot);

28

}

else

{

29

console.log(

'Got: '

+ dataGot);

30

}

31

});