В этой статье я хочу описать свой опыт работы на фрилансе.

Что за фриланс?

Может быть есть люди, которые не знают, что такое фриланс? “Freelance” буквально переводится как “внештатно”, соответственно “freelancer” — “внештатный сотрудник”. Обычно это подразумевает поиск заказов через интернет, выполнение их дома за компьютером (хотя некоторые ловко трудятся во время основной работы ) и оплату выполненной работы через интернет. Существуют специальные сайты — фриланс-биржы — на которых происходит общение заказчиков, имеющих какие-либо задания, и исполнителей, готовых эти задания выполнить.

А зачем это нужно?

Наверное каждый программист замечал, что работая постоянно, у него не хватает времени заниматься какими-то своими проектами. А различные идеи периодически приходят, и думаешь: “Вот было бы время, обязательно бы это реализовал”. Да и на работе бывают времена, что приходится заниматься неинтересными делами. Тем более в мои планы не входило всю жизнь работать “на дядю”, рано или поздно пришлось бы уходить на вольные хлеба, и во время особо скучного периода на тогдашней постоянной работе я и решил это сделать.

Для начала я решил закрепиться на фриланс-биржах, чтобы в случае чего всегда можно было бы заработать денег, невзирая на текущую жизненную ситуацию, был бы под рукой ноутбук и интернет. К тому же всегда есть из чего выбрать: захотел делать сайт — вперед, захотел написать скрипт — флаг в руки, надоел язык программирования — меняй, никто не запрещает.

Биржи? Биржи. Биржи…

Фриланс-бирж существует множество, как российских, так и зарубежных, в итоге я зарегистрировался на трех — freelancer.com, free-lance.ru и weblancer.net.

freelancer.com я выбрал, так как прочитал довольно интересную статью, описывающую прелесть работы на ней. Здесь я решил представиться веб-студией, по идее такой подход вызывает больше доверия у заказчиков, придумал “конторе” название, сделал простенький логотип, зарегистрировался и начал осматриваться.
Если описать в общем, сайт представляет собой типичную фриланс-биржу – страницы разделов по возможным IT-работам, например создание сайтов “под ключ”, создание дизайнов, работа с различными CMS, написание скриптов, системное администрирование и т.д. Заказчик выбирает нужный ему раздел, создает проект, на который откликаются заинтересовавшиеся фрилансеры.

На freelancer.com ищут заказы очень много фрилансеров, среди которых немало выходцев из Азии. Качество работы большинства этих товарищей, как и знание английского языка, оставляет желать лучшего (кто не слышал про программистов-индусов ), но они берут ценами, иногда демпинг с их стороны вызывает даже не недоумение, а смех. Вполне реально найти “исполнителя” на сложный специфичный портал за сумму например 100$ и сроком исполнения 3 дня. И это предложение еще могут перебить!
Естественно, есть и мастера своего дела, с высочайшим профессионализмом, большим опытом и умением подойти к клиенту.

К сожалению, на этом сайте мне так и не удалось получить ни одного заказа, наверное из-за окончательной переориентации на отечественный рынок. Свою роль сыграли и не очень удовлетворительный английский, и разница во времени с многими заказчиками.

Российские биржи, на которых я зарегистрировался — free-lance.ru и weblancer.net. free-lance.ru – самая известная из отечественных, держит первенство по количеству проектов и активных фрилансеров. Содержит много платных услуг, жизнь без которых затруднена, например не имея pro-аккаунта можно подавать только три заявки на понравившиеся проекты в сутки. Но таким ограничением страдают все биржи, которые я встречал. Впрочем это мне не очень мешало, с первых дней мне хотелось насладится преимуществом выбора интересных заданий. К сожалению, появлялись они не так часто, как хотелось бы, а при подаче заявки меня всегда обходили более опытные исполнители, с отзывами и более долгим временем нахождения на сайте.

Про это стоит упомянуть подробнее. Практически все заказчики смотрят на количество отзывов, имеющихся у фрилансера, которые оставили прошлые работодатели. Хорошо выполнил работу — написали положительный, плохо, не выполнил или исчез — отритцательный. Наверное уже с 3-мя отритцательными отзывами лучше завести новый аккаунт, так же как и если первый отзыв — негативный. То же самое и с временем, прошедшим после регистрации, некоторые не доверяют людям, у которых оно меньше месяца. Сначала порой приходилось работать и за еду просто за отзыв.

Когда подходящий проект найден, встает задача, чтобы заказчик выбрал именно вас. Тут у каждого свой подход, кто-то просто называет цену и оставляет сообщение “пишите в личку”, кто-то строчит простыни текста, в подробностях расписывая все свои предыдущие достижения, кто-то выбирает нечто среднее. По-моему стоит писать, какие подобные задания уже приходилось выполнять и по-возможности дать понять, что понимаешь задание и чуть ли не начал его делать.

Но вот первый проект получен, наконец-то меня выбрали исполнителем! Обсудив все детали задания, пора начинать работать! Но, что все не так просто, стало понятно через пару проектов. ТЗ и детали нужно обговаривать ОЧЕНЬ подробно, выясняя все до последних мелочей, иначе дорабатывать и изменять казалось бы незначительные и неважные детали и наводить красоту по вкусу заказчика можно вечно, либо, неправильно поняв суть задания, вообще выбрать неверный путь решения задачи. Был случай, когда недели две работы потратились впустую из-за непонимания и несогласованности между мной и заказчиком, в итоге я потерял деньги, а клиент время, хорошо, что в результате разошлись мирно, без написания отритцательных отзывов друг другу.

И наконец, самый приятный момент — оплата. На всех биржах есть сервисы безопасных сделок, которые сделаны для того, чтобы ни работодатель, ни исполнитель не обманывали друг друга. Я ими не пользовался ни разу, предпочитая или доверять заказчику, получая деньги после выполнения задания, или беря предоплату. В подавляющем большинстве случаев оплата происходит с помощью вебмани или яндекс-денег.

Не биржей единой

Поиск заказов не ограничивается только биржами.
У многих заказчиков постоянно появляются новые задания, и если ты хорошо выполнил одно, наверняка следующее также достанется тебе, плюс этот заказчик будет рекомендовать тебя своим знакомым, у которых возникла необходимость в привлечении стороннего сотрудника.
Постепенно знакомые и бывшие коллеги узнают о твоей работе на фрилансе и заказы начинают приходить через них.
Через некоторое время я перестал заходить на биржи и выполнял только подобные задания, потому что они скорее всего будут интересные, с заказчиком уже сложились более-менее неплохие отношения, почти нет недоверия и настороженности, как у тебя, что прокатят с деньгами, так и у него, что работа не будет выполнена.

Также не стоит забывать про свои задумки, отводить какое-то время на них, даже если пока ни одна из них еще не приносит какой-либо ощутимой отдачи, ведь это только пока Главное, что для них находится время.

Ожидания и реальность

Для кого-то работать дома в кайф, но я знал, что постоянно находиться в четырех стенах мне будет затруднительно, однако утешал себя мыслью, что можно будет выйти, например, в парк и работать там. Но на практике зарядки ноутбука хватает не намного времени, у нетбука маленький экран, а на лавке в парке с этими девайсами неудобно сидеть. Если еще вспомнить, каким жарким было лето 2010, то можно понять, как я завидовал людям, сидящим в прохладных офисах с кондиционерами, тогда как дома был только плохо спасающий от этого ада вентилятор.

Когда я начинал свой путь по дороге фриланса, то не строил иллюзий, что в первый же день клиенты выстроятся в очередь, но все же было неожиданно, что уцепиться за первый проект удалось только недели через две. Эта ситуация получилась и из-за того, что, как упоминалось ранее, я не откликался на неинтересные заявки, а ждал чего-то более привлекательного. Зато проект оказался интересным, довольно денежным и с хорошим заказчиком, которому впоследствии я выполнил еще несколько заданий.

По поводу рабочего времени происходило примерно так, как я и думал: то работы нет, то работать приходится по ночам, не говоря уже про выходные. Если на постоянной работе знаешь, что в субботу-воскресенье отдыхаешь, на фрилансе все смешивается и иногда удивляешься радости друзей о том, что завтра выходной.
Можно безболезненно с утра покататься на велосипеде, посреди рабочего дня прерваться, например, на гантели или прогулку (это если нет срочной работы, конечно ).

Волнующий денежный вопрос. Честно говоря, когда я уходил на фриланс, то ожидал, что буду зарабатывать больше. Очень сложно назвать среднюю сумму заработка, в первые месяцы у меня выходило не более 10-15 тысяч ежемесячно.

Итого

Что же в итоге? Не жалею ли я о том, что ушел с постоянной работы на фриланс? Нет.
Сейчас я частично (5 часов в день) работаю в офисе на постоянной работе, которая нашла меня через фриланс, остальное время практически полностью посвящаю своим делам, лишь иногда откликаясь на работу от постоянных заказчиков, приобретенных на фрилансе.

В заключение хочу выразить огромную благодарность своей девушке Саше, которая была со мной и поддерживала меня все это время.

Предлагаю вашему вниманию третью статью из цикла “Многопоточность” в PHP. В данной статье мы рассмотрим асинхронные или неблокирующие сокеты.

Обычно, когда мы открываем несколько сокетов, мы делаем это последовательно, т.е. открываем соединение к одному, ждем завершения соединения, что-либо делаем, закрываем, открываем следующий и т.д. Налицо неудобство такого подхода, когда ресурсов для соединения у нас много и с ними производятся одинаковые действия. Хорошо, если бы можно было не дожидаться завершения соединения, а сразу же открывать следущее. И такая возможность существует.

Но сначала давайте разберем само понятие “сокет”. Что такое сокет?

Сокеты — это название программного интерфейса для обеспечения информационного обмена между процессами. Процессы при таком обмене могут исполняться как на одном компьютере, так и на различных, связанных между собой сетью. Сокет — абстрактный объект, представляющий конечную точку соединения.

В нашем случае сокет будет представлять собой соединение между нашей программой и компьютером, с которого требуется получить необходимую информацию.

Работа с сокетами достаточно проста:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<?php
$url = 'www.mail.ru';
// создаем сокет
$sh = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
// определяем ip хоста
$ip = gethostbyname($url);
// открываем сокет
socket_connect($sh, $ip, '80');
// формируем http-заголовки
$headers  = "GET / HTTP/1.0\r\n";
$headers .= "Host: ".$url."\r\n";
$headers .= "User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; ru; rv:1.9.0.6) Gecko/2009011913 MRA 5.3 (build 02557) Firefox/3.0.6\r\n";
$headers .= "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n";
$headers .= "Accept-Language: ru,en-us;q=0.7,en;q=0.3\r\n";
$headers .= "Accept-Charset: windows-1251,utf-8;q=0.7,*;q=0.7\r\n";
$headers .= "\r\n";
// записываем данные в сокет
socket_write($sh, $headers, strlen($headers));
// читаем данные из сокета
$result = '';
while ($r = socket_read($sh, 1024)) $result .= $r;
?>

Сначала функцией socket_create инициализируем сокет и задаем его характеристики – флаг AF_INET, переданный в качестве первого параметра, указывает, что создается сокет для интернета, второй параметр – тип сокета (самые распространенные – TCP и UDP) нам нужен TCP-сокет – SOCK_STREAM, и третий параметр задает протокол (TCP).
Затем с помощью функции socket_connect происходит соединение к указанному адресу и порту. Надо заметить, что эта функция принимает в качестве параметра не сам адрес хоста, а его ip адрес, поэтому сначала мы должны его определить функцией gethostbyname.
Теперь нам надо сформировать запрос, который мы отправим на сервер (подробнее о http-заголовках можно почитать в статье PHP и HTTP). Собственно отправку производит функция socket_write, второй параметр которой – это то, что мы отправляем и третий – длина отправляемой строки (т.е. всех сформированных заголовков).
Запись произведена, теперь функцией socket_read читаем данные, переданные для нас сервером.
В результате в переменной $result хранится хтмл, который нам необходим.

Задача у нас стоит та же, что и в предыдущих примерах: получить содержимое нескольких html-страниц. Вот код, реализующий это:

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

<?php
// страницы, содержимое которых надо получить
$urls = array('www.yandex.ru', 'www.google.ru', 'www.mail.ru', 'www.rambler.ru');
 
$rtasks = array(); // задачи чтения
$wtasks = array(); // задачи записи
$results = array(); // результаты
 
foreach ($urls as $url) {
	// открываем отдельный сокет
	$sh = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
	if (!$sh) continue;
 
	// таймаут для чтения
	socket_set_option($sh, SOL_SOCKET, SO_RCVTIMEO, array("sec" => 10, "usec" => 0));
	// таймаут для записи
	socket_set_option($sh, SOL_SOCKET, SO_SNDTIMEO, array("sec" => 10, "usec" => 0));
	// задаем неблокирующий режим сокетов
	socket_set_nonblock($sh);
	// определяем ip хоста
	$ip = gethostbyname($url);
	// соединяемся
	socket_connect($sh, $ip, 80);
 
	// добавляем в задачи для записи
	$wtasks[$url] = $sh;
}
 
// продолжаем, пока есть задачи для записи или чтения
while ($wtasks || $rtasks) {
	// массив для сокетов с возможностью чтения
	$rtasks_ = $rtasks;
	// массив для сокетов с возможностью записи
	$wtasks_ = $wtasks;
 
	// ждем результатов из сокетов
	$n = socket_select($rtasks_, $wtasks_, $e=null, 10);
	if ($n > 0) {
		// сокеты, доступные для записи
		foreach ($wtasks_ as $sh) {
			// ищем урл страницы по дескриптору сокета в массиве задач записи
			$url = array_search($sh, $wtasks);
			// удаляем из задач записи
			unset($wtasks[$url]);
			// добавляем в задачи чтения
			$rtasks[$url] = $sh;
			// формируем http-заголовки
			$headers  = "GET / HTTP/1.0\r\n";
			$headers .= "Host: ".$url."\r\n";
			$headers .= "User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; ru; rv:1.9.0.6) Gecko/2009011913 MRA 5.3 (build 02557) Firefox/3.0.6\r\n";
			$headers .= "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n";
			$headers .= "Accept-Language: ru,en-us;q=0.7,en;q=0.3\r\n";
			$headers .= "Accept-Charset: windows-1251,utf-8;q=0.7,*;q=0.7\r\n";
			$headers .= "\r\n";
 
			// записываем в сокет
			if (socket_write($sh, $headers) === false) fclose($sh);
		}
 
		// сокеты, доступные для чтения
		foreach ($rtasks_ as $sh) {
			// ищем урл страницы по дескриптору сокета в массиве задач чтения
			$url = array_search($sh, $rtasks);
			if (!$url) continue;
			// считываем результат из сокета
			$result = '';
			while ($r = socket_read($sh, 1024)) $result .= $r;
			// закрываем сокет
			socket_close($sh);
			// удаляем из задач чтения
			unset($rtasks[$url]);
			// заносим html в массив результатов
			$results[$url] = $result;
		}
	}
	else {
		break;
	}
}
?>

Можно заметить, что код несильно отличается от кода для stream-функций.

В общих словах здесь происходит следующее. Каждый сокет инициализируется и переводится в неблокирующий режим. Затем в цикле производится проверка готовых к чтению или записи сокетов, и если такие существуют, производится соответствующая операция. Все действия протекают в асинхронном порядке, т.е не ждут окончания предыдущей операции. Например, если данные с мэйл.ру поступили раньше, чем от яндекса, то будут обрабатываться именно они, хотя коннект к яндексу мог произойти до коннекта к мэйлу. Можно сказать, что все происходит в несколько “потоков”, когда параллельно ожидается готовность каждого сокета к какому-либо действию.

Теперь разберем код более подробно.
Итак, у нас есть массив с адресами страниц. В строке 9 запускается цикл для инициализации соединения с каждым хостом. В 11 строке создается сокет, затем в 15 и 17 строках мы задаем таймауты для чтения и записи соответственно. В 19 строчке функцией socket_set_nonblock задаем неблокирующий режим, превращающий каждый наш сокет в асинхронный. Это необходимо для того, чтобы после очередной операции над сокетом не происходило ожидание ее окончания, а продолжал работу остальной код программы. В 26 строке заносим инициализированный сокет в массив сокетов для записи.

Основной цикл начинается в 30 строчке. Он будет продолжаться до тех пор, пока у нас остаются сокеты, в которые нужно записать или из которых надо прочитать.
В 32 строке массиву $rtasks_ присваиваем массив сокетов, из которых должна быть прочитана информация. В 34-ой в $wtasks_ заносится массив с сокетами, в которые необходимо произвести запись.
Главная функция в этом цикле – socket_select. Она принимает на вход массивы сокетов, ожидающих чтения, ожидающих запись и массив для исключительных ситуаций, четвертый параметр, передаваемый в данную функцию – таймаут. Параметры-массивы передаются по ссылке, т.е когда произойдет ожидаемое событие (socket_select в этом случае вернет число больше 0), в них появятся соответствующие дескрипторы.
Если нашлись сокеты, доступные для записи, ищем урл, соответствующий каждому из готовых сокетов, и функцией socket_write записываем в него заголовки для получения хтмл страницы в ответе. Так же в 44-ой строке удаляем дескриптор из массива для записи, так как она будет произведена, и заносим его в строке 46 в массив для чтения, чтобы потом получить интересующий нас ответ.
Если же имеются сокеты, готовые нам ответить, считываем из них информацию функцией socket_read.
Profit! В массиве $results содержится вожделенный хтмл-код!

Замечание:
При вызове функции socket_connect, когда сокет переведен в неблокирующий режим функцией socket_set_nonblock, выдается предупреждение “Operation now in progress” (”Операция на незаблокированном сокете не может быть завершена немедленно”), а socket_connect возвращает false. Несмотря на это, код нормально отрабатывает.

Это вторая статья из серии “Многопоточность” в PHP.

В прошлый раз мы рассмотрели curl, теперь давайте поговорим о stream-функциях.

Вольный перевод документации:

Streams (потоки) были введены в PHP 4.3.0 как способ обобщить работу с файлами, сетью, сжатием данных и другими процессами, которые совместно используют единый набор функций. В простейшем определении, поток – объект ресурса, имеющий “потокообразное” поведение, т.е. из которого можно читать, в который можно писать и внутри которого можно перемещаться.

stream_socket-функции являются частью streams, при помощи них мы можем коннектиться или писать/читать данные, не дожидаясь завершения предыдущей операции.

Итак, дано: массив с урлами. Задача: непоследовательно получить их содержимое.

Давайте рассмотрим код, который решает поставленную нами задачу:

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

<?php
// страницы, содержимое которых надо получить
$urls = array('www.yandex.ru', 'www.google.ru', 'www.mail.ru', 'www.rambler.ru');
 
$rtasks = array(); // задачи чтения
$wtasks = array(); // задачи записи
$results = array(); // результаты
 
foreach ($urls as $url) {
    // открываем отдельный сокет
    $sh = stream_socket_client($url.':80', $errno, $errstr, 10,
        STREAM_CLIENT_ASYNC_CONNECT|STREAM_CLIENT_CONNECT);
    if (!$sh) continue;
    // добавляем в задачи для записи
    $wtasks[$url] = $sh;
}
 
while ($wtasks || $rtasks) {
    // массив для сокетов с возможностью чтения
    $rtasks_ = $rtasks;
    // массив для сокетов с возможностью записи
    $wtasks_ = $wtasks;
 
    // ждем результатов из сокетов
    $n = stream_select($rtasks_, $wtasks_, $e=null, 10);
    if ($n > 0) {
        // сокеты, доступные для записи
        foreach ($wtasks_ as $sh) {
            // ищем урл страницы по дескриптору сокета в массиве задач записи
            $url = array_search($sh, $wtasks);
            // удаляем из задач записи
            unset($wtasks[$url]);
            // добавляем в задачи чтения
            $rtasks[$url] = $sh;
            // формируем http-заголовки
            $headers  = "GET / HTTP/1.0\r\n";
            $headers .= "Host: ".$url."\r\n";
            $headers .= "User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; ru; rv:1.9.0.6) Gecko/2009011913 MRA 5.3 (build 02557) Firefox/3.0.6\r\n";
            $headers .= "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n";
            $headers .= "Accept-Language: ru,en-us;q=0.7,en;q=0.3\r\n";
            $headers .= "Accept-Encoding: gzip,deflate\r\n";
            $headers .= "Accept-Charset: windows-1251,utf-8;q=0.7,*;q=0.7\r\n";
            $headers .= "\r\n";
            // записываем в сокет
            if (fwrite($sh, $headers) === false) fclose($sh);
        }
 
        // сокеты, доступные для чтения
        foreach ($rtasks_ as $sh) {
            // ищем урл страницы по дескриптору сокета в массиве задач чтения
            $url = array_search($sh, $rtasks);
            if (!$url) continue;
            // считываем результат из сокета
            $result = '';
            while ($r = fread($sh, 8192)) $result .= $r;
            // закрываем сокет
            fclose($sh);
            // удаляем из задач чтения
            unset($rtasks[$url]);
            // заносим html в массиы результатов
            $results[$url] = $result;
        }
    }
    else {
        break;
    }
}
?>

Сначала инициализируются три массива: $rtasks – в него будут заноситься сокеты, из которых можно читать данные, $wtasks – для сокетов, готовых к записи, и $results – массив для сохранения содержимого заданных страниц.

Затем в цикле функцией stream_socket_client открываются сокеты для каждого из урлов, при этом ставится флаг STREAM_CLIENT_ASYNC_CONNECT, который указывает, что каждое следующее соединение надо открывать не дожидаясь завершения открытия предыдущего. Флаг STREAM_CLIENT_CONNECT указывает, что мы создаем именно клиентское подключение.
Дескрипторы сокетов заносятся в массив $wtasks.

В 18-ой строке начинается главный цикл, и сразу массивам $rtasks_ и $wtasks_, передаваемым в функцию stream_select, присваиваются массивы, в которых хранятся сокеты для чтения и записи соответственно. Функция stream_select отслеживает наличие данных в потоках и принимает на вход несколько параметров: первый – это массив дескрипторов, в которых ожидается завершение операции чтения, второй – массив с дескрипторами, ожидающими завершение записи, третий – для особых случаев (поступление “out-of-band data” – внеполосных данных) и четвертый параметр – это таймаут. Массивы передаются в функцию по указателям, и как только функция возвращает число больше 0, в них будут находится сокеты, готовые к действиям.

В 28-ой строке мы смотрим, в какие сокеты можно записать данные (надо что-то отправить, прежде чем нам придет ответ-результат), и если такие сокеты есть, то удаляем из массива для записи текущий дескриптор, помещаем его в массив для чтения, и отправляем заголовки, необходимые для получения контента.
Далее, в 49-ой строчке, просматриваем сокеты, готовые для считывания из них данных, забираем содержимое, удаляем дескриптор из масива для чтения и закрываем сокет. Результат заносим в массив $results. Повторяем эти операции до тех пор, пока у нас остаются какие-либо открытые сокеты.

После работы скрипта нужный нам контент находится в массиве $results.

В статье рассмотрен пример работы с функциями stream_socket_*, на очереди асинхронные сокеты.

Эта статья является первой из серии “Многопоточность” в PHP

Curl – это библиотека, позволяющая подсоединяться к разным серверам по разным протоколам. Обладает удобством в работе и способностью гибко настраиваться.
Curl реализует механизм множественных запросов, или мультизапросов. Его принцип заключается в том, что посылается несколько запросов, при этом перед отправкой следующего не ожидается ответ на предыдущий.

Используем это в нашем примере скачивания нескольких страниц.

Рассмотрим сначала процесс скачивания содержимого с одного url.

1
2
3
4
5
6
7
8
9
10
11
12
13

<?php
$url = 'mail.ru';
// инициализация сеанса curl
$ch = curl_init('http://'.$url);
// curl_exec будет возвращать результат
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
// не будет возвращаться http-заголовок
curl_setopt($ch, CURLOPT_HEADER, 0);
// загрузка страницы и выдача её браузеру
$content = curl_exec($ch);
// завершение сеанса и освобождение ресурсов
curl_close($ch);
?>

Здесь функцией curl_init мы инициализируем сеанс curl и в качестве параметра передаем урл страницы, которую хотим скачать. Далее первым вызовом функции curl_setopt говорим, что результат надо вернуть, а не вывести в браузер, и вторым запрещаем передачу нам http-ответа сервера. curl_setopt принимаюет в качестве параметров дескриптор соединения $ch, название опции и ее значение соответственно. С помощью curl_setopt можно задать много параметров для более тонкого управления соединением, подробнее читайте в мануале к этой библиотеке. Затем функцией curl_exec производим собственно скачивание и в завершении закрываем соединение – curl_close. В переменной $content у нас теперь находится код страницы, указанной в $url.

А сейчас давайте попробуем скачать сразу несколько страниц (основа примера взята из документации на php.net):

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

<?php
 
// страницы, содержимое которых надо получить
$urls = array('yandex.ru', 'google.ru', 'mail.ru', 'rambler.ru');
 
// инициализируем "контейнер" для отдельных соединений (мультикурл)
$cmh = curl_multi_init();
 
// массив заданий для мультикурла
$tasks = array();
// перебираем наши урлы
foreach ($urls as $url) {
	// инициализируем отдельное соединение (поток)
	$ch = curl_init('http://'.$url);
	// если будет редирект - перейти по нему
	curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
	// возвращать результат
	curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
	// не возвращать http-заголовок
	curl_setopt($ch, CURLOPT_HEADER, 0);
	// таймаут соединения
	curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 10);
	// таймаут ожидания
	curl_setopt($ch, CURLOPT_TIMEOUT, 10);
	// добавляем дескриптор потока в массив заданий
	$tasks[$url] = $ch;
	// добавляем дескриптор потока в мультикурл
	curl_multi_add_handle($cmh, $ch);
}
 
// количество активных потоков
$active = null;
// запускаем выполнение потоков
do {
	$mrc = curl_multi_exec($cmh, $active);
} 
while ($mrc == CURLM_CALL_MULTI_PERFORM);
 
// выполняем, пока есть активные потоки
while ($active && ($mrc == CURLM_OK)) {
	// если какой-либо поток готов к действиям
	if (curl_multi_select($cmh) != -1) {
		// ждем, пока что-нибудь изменится
		do {
			$mrc = curl_multi_exec($cmh, $active);
			// получаем информацию о потоке
			$info = curl_multi_info_read($cmh);
			// если поток завершился
			if ($info['msg'] == CURLMSG_DONE) {
				$ch = $info['handle'];
				// ищем урл страницы по дескриптору потока в массиве заданий
				$url = array_search($ch, $tasks);
				// забираем содержимое
				$tasks[$url] = curl_multi_getcontent($ch);
				// удаляем поток из мультикурла
				curl_multi_remove_handle($cmh, $ch);
				// закрываем отдельное соединение (поток)
				curl_close($ch);
			}
		}
		while ($mrc == CURLM_CALL_MULTI_PERFORM);
	}
}
 
// закрываем мультикурл
curl_multi_close($cmh);
 
?>

Код подробно откомментирован, но давайте разберем все по порядку.
В 7 строчке мы инициализируем контейнер для отдельных соединений curl (далее я буду называть его мультикурл), именно он позволит нам проводить операции с ними параллельно.
Далее в цикле инициализируем соединение (назовем его поток) для каждого урла из нашего массива, попутно добавляя его в мультикурл и в массив заданий $tasks. $tasks – массив, в котором ключами являются адреса наших страниц, а значениями – соответствующие дескрипторы curl. Функция curl_multi_add_handle добавляет к дескриптору нашего мультизапросного соединения отдельное созданное соединение.

В 34 строке запускается цикл для начала работы нашего мультикурла. Функция curl_multi_exec одновременно отправляет на выполнение все объявленные потоки, при этом в переменную $active заносится количество выполняемых потоков.

В основном цикле, начинающемся на 40 строчке, происходят главные действия. Он выполняется до тех пор, пока есть незавершенные потоки или пока не произошла ошибка. В 42 строке вызывается функция curl_multi_select, которая проверяет готовность какого-либо из потоков к дальнейшим действиям с ним. Затем, в 47 строке, функцией curl_multi_info_read получаем информацию о потоке. Но так как curl_multi_info_read обновляет возвращаемую информацию только после вызова curl_multi_exec, сделаем это в строке 45.

Функция curl_multi_info_read возвращает массив, в котором нас интересуют ключи ‘msg’ и ‘handle’. По ‘msg’ мы проверяем, выполнился ли поток, а по ‘handle’ узнаем его дескриптор. Получив дескриптор, ищем по массиву заданий, к какому урлу он относится и записываем вместо него вожделенное содержимое страницы, получаемое функцией curl_multi_getcontent.
Теперь, когда данный поток выполнил свою задачу, удаляем его из мультикурла, а потом закрываем самого.

После завершения всех потоков функцией curl_multi_close закрываем мультикурл.

Сейчас в массиве заданий $tasks находятся html-коды заданных страниц.

Надеюсь, после прочтения статьи стало немного понятнее, как можно реализовать выполнение “многопоточных” запросов на PHP.

В следующей статье рассмотрим использование stream-функций для подобных целей.

Эта небольшая серия статей является обобщением материала, найденного в интернете и не претендует на оригинальность. Идея ее написать возникла у меня после поиска информации по каждому из пунктов данного материала, чтобы облегчить задачу тем, кому придется столкнуться с данной темой.

Сразу хочу сказать, что многопоточности в PHP нет. Не зря слово многопоточность в заголовке взято в кавычки. Да, существует многопроцессность, реализующаяся средствами операционной системы (этот случай будет разобран), многозадачность, но многопоточности не существует. Однако некоторые задачи все-таки можно выполнять параллельно.

Возьмем пример, встречающийся достаточно часто: скачать программно содержимое нескольких страниц. Если страниц немного, то их можно без проблем и больших затрат времени загрузить последовательно. Но если их тысячи? И вот здесь можно применить подходы, позволяющие выполнить скачивание одновременно. Некоторые из них и будут подробно описаны в данном материале. Сначала мы рассмотрим использование библиотеки curl, которая может производить загрузку одновременно нескольких страниц. Затем попробуем применить к нашей задаче stream-функции. После этого сделаем то же самое с помощью асинхронных сокетов. И наконец распараллелим наш процесс функцией fork.

Все способы проверены на личном опыте. Для примеров взят максимум простой код, без оптимизации, его цель – показать принципы работы каждого метода.

Для вступления рассмотрим такой способ, как

Вызов одновременно нескольких копий скрипта

Суть состоит в том, что один скрипт вызывается с разными параметрами, разбивающими задачу на несколько одинаковых подзадач.

Пример. Пусть у нас есть скрипт getcontent.php

1
2
3
4
5
6
7
8
9
10

<?php
$urls = array('yandex.ru', 'google.ru', 'rambler.ru', 'bing.com', 'mail.ru');
 
$k = $_GET['k'];
$url = $urls[$k];
$content = file_get_contents('http://'.$url);
$f = fopen($k.'.cont', 'w');
fwrite($f, $content);
fclose($f);
?>

Здесь $urls – массив урлов, содержимое с которых нам надо получить.
Вызывая этот скрипт как getcontent.php?k=n , где n равен какому-либо ключу массива $urls, мы получим на жестком диске файл с именем n.cont, в котором и сохранен html интересующей нас страницы.

Теперь откроем в браузере пять вкладок, напишем в адресной строке первой http://путь/getcontent.php?k=0, адресной строке второй http://путь/getcontent.php?k=1 и т.д. до http://путь/getcontent.php?k=4 и в каждой быстро нажмем Enter. Если теперь зайти в папку с нашим скриптом, то мы увидим там 5 файлов с html сайтов из масива, причем их получение произошло практически (зависит от того, как быстро жать enter) одновременно. Вот на таком нехитром примере мы показали простейший способ выполнения одного задания в несколько “потоков”

Недостаток этого способа в том, что на каждый запущенный скрипт выделяется определенное количество памяти, общее количество которой в данном случае пропорционально количеству запущенных копий скрипта. Другой минус – неудобство управлением данными.

В следующей статье мы попробуем для достижения нашей цели воспользоваться более гуманным способом – использовать библиотеку curl.