Zy Filemanager

📁 File Browser

Name	Size	Permissions	Actions
📄 php_swoole_call_stack.h (1,858 bytes)	1.81 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_client.h (2,859 bytes)	2.79 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_coroutine.h (10,087 bytes)	9.85 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_coroutine_system.h (1,934 bytes)	1.89 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_curl.h (5,188 bytes)	5.07 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_cxx.h (27,696 bytes)	27.05 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_firebird.h (4,986 bytes)	4.87 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_ftp_def.h (1,201 bytes)	1.17 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_http.h (16,642 bytes)	16.25 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_http_server.h (4,220 bytes)	4.12 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_library.h (435,731 bytes)	425.52 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_odbc.h (5,757 bytes)	5.62 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_oracle.h (3,043 bytes)	2.97 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_pgsql.h (2,611 bytes)	2.55 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_private.h (45,902 bytes)	44.83 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_process.h (1,559 bytes)	1.52 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_server.h (7,035 bytes)	6.87 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_sqlite.h (2,257 bytes)	2.2 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_ssh2.h (2,364 bytes)	2.31 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_ssh2_def.h (1,315 bytes)	1.28 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_ssh2_hook.h (22,423 bytes)	21.9 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_stdext.h (1,883 bytes)	1.84 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_thread.h (11,040 bytes)	10.78 KB	0644	✍️ ⬇️ 🗑️
📄 php_swoole_websocket.h (2,545 bytes)	2.49 KB	0644	✍️ ⬇️ 🗑️
📄 swoole_curl_interface.h (2,363 bytes)	2.31 KB	0644	✍️ ⬇️ 🗑️

✍️ Editing: php_swoole_thread.h

            File: /opt/alt/php84/usr/include/php/ext/swoole/ext-src/php_swoole_thread.h

            Size: 10.78 KB | 
            Last Modified: 2026-03-18 16:07:52        

/*
  +----------------------------------------------------------------------+
  | Swoole                                                               |
  +----------------------------------------------------------------------+
  | This source file is subject to version 2.0 of the Apache license,    |
  | that is bundled with this package in the file LICENSE, and is        |
  | available through the world-wide-web at the following url:           |
  | http://www.apache.org/licenses/LICENSE-2.0.html                      |
  | If you did not receive a copy of the Apache2.0 license and are unable|
  | to obtain it through the world-wide-web, please send a note to       |
  | license@php.net so we can mail you a copy immediately.               |
  +----------------------------------------------------------------------+
  | Author: Twosee  <twose@qq.com>                                       |
  | Author: Tianfeng Han  <rango@swoole.com>                             |
  +----------------------------------------------------------------------+
*/

#pragma once

#include "php_swoole_cxx.h"

#ifdef SW_THREAD
#include "swoole_thread.h"

typedef uint32_t ThreadResourceId;
class ThreadResource;
class ZendArray;

extern zend_class_entry *swoole_thread_ce;
extern zend_class_entry *swoole_thread_error_ce;
extern zend_class_entry *swoole_thread_arraylist_ce;
extern zend_class_entry *swoole_thread_atomic_ce;
extern zend_class_entry *swoole_thread_atomic_long_ce;
extern zend_class_entry *swoole_thread_barrier_ce;
extern zend_class_entry *swoole_thread_lock_ce;
extern zend_class_entry *swoole_thread_map_ce;
extern zend_class_entry *swoole_thread_queue_ce;

void php_swoole_thread_start(std::shared_ptr<swoole::Thread> thread, zend_string *file, ZendArray *argv);
void php_swoole_thread_bailout();

ThreadResource *php_swoole_thread_arraylist_cast(const zval *zobject);
ThreadResource *php_swoole_thread_map_cast(const zval *zobject);
ThreadResource *php_swoole_thread_queue_cast(const zval *zobject);
ThreadResource *php_swoole_thread_lock_cast(const zval *zobject);
ThreadResource *php_swoole_thread_atomic_cast(const zval *zobject);
ThreadResource *php_swoole_thread_atomic_long_cast(const zval *zobject);
ThreadResource *php_swoole_thread_barrier_cast(const zval *zobject);

void php_swoole_thread_arraylist_create(zval *return_value, ThreadResource *resource);
void php_swoole_thread_map_create(zval *return_value, ThreadResource *resource);
void php_swoole_thread_queue_create(zval *return_value, ThreadResource *resource);
void php_swoole_thread_lock_create(zval *return_value, ThreadResource *resource);
void php_swoole_thread_atomic_create(zval *return_value, ThreadResource *resource);
void php_swoole_thread_atomic_long_create(zval *return_value, ThreadResource *resource);
void php_swoole_thread_barrier_create(zval *return_value, ThreadResource *resource);

int php_swoole_thread_stream_cast(zval *zstream);
void php_swoole_thread_stream_create(zval *return_value, zend_long sockfd);

int php_swoole_thread_co_socket_cast(zval *zstream, swSocketType *type);
void php_swoole_thread_co_socket_create(zval *return_value, zend_long sockfd, swSocketType type);

#define EMSG_NO_RESOURCE "resource not found"
#define ECODE_NO_RESOURCE (-2)

enum {
    IS_ARRAYLIST = 80,
    IS_QUEUE = 81,
    IS_LOCK = 82,
    IS_MAP = 83,
    IS_BARRIER = 84,
    IS_ATOMIC = 85,
    IS_ATOMIC_LONG = 86,
    IS_PHP_SOCKET = 96,
    IS_CO_SOCKET = 97,
    IS_STREAM_SOCKET = 98,
    IS_SERIALIZED_OBJECT = 99,
};

class ThreadResource {
    sw_atomic_t ref_count;

public:
    ThreadResource() {
        ref_count = 1;
    }

void add_ref() {
        sw_atomic_add_fetch(&ref_count, 1);
    }

void del_ref() {
        if (sw_atomic_sub_fetch(&ref_count, 1) == 0) {
            delete this;
        }
    }

protected:
    virtual ~ThreadResource() = default;
};

struct ArrayItem {
    uint32_t type = IS_UNDEF;
    zend_string *key = nullptr;
    union {
        zend_string *str;
        zend_long lval;
        double dval;
        struct {
            int fd;
            swSocketType type;
        } socket;
        zend_string *serialized_object;
        ThreadResource *resource;
    } value;

explicit ArrayItem(zval *zvalue) {
        value = {};
        store(zvalue);
    }

void setKey(zend::String &_key) {
        key = zend_string_init(_key.val(), _key.len(), true);
    }

void setKey(const zend_string *_key) {
        key = zend_string_init(ZSTR_VAL(_key), ZSTR_LEN(_key), true);
    }

void store(zval *zvalue);
    void fetch(zval *return_value) const;
    void release();
    bool equals(const zval *zvalue) const;

static int compare(Bucket *a, Bucket *b);

~ArrayItem() {
        if (value.str) {
            release();
        }
        if (key) {
            zend_string_release(key);
        }
    }
};

class ZendArray : public ThreadResource {
  protected:
    swoole::RWLock lock_;
    zend_array ht;

static void item_dtor(zval *pDest) {
        auto item = static_cast<ArrayItem *>(Z_PTR_P(pDest));
        delete item;
    }

public:
    ZendArray() : lock_(false) {
        zend_hash_init(&ht, 0, NULL, item_dtor, 1);
    }

~ZendArray() override {
        zend_hash_destroy(&ht);
    }

void clean() {
        lock_.lock();
        zend_hash_clean(&ht);
        lock_.unlock();
    }

void append(zval *zvalue);

void add(const zend_string *skey, zval *zvalue) {
        auto item = new ArrayItem(zvalue);
        item->setKey(skey);
        zend_hash_add_ptr(&ht, item->key, item);
    }

void add(zend::String &skey, zval *zvalue) {
        auto item = new ArrayItem(zvalue);
        item->setKey(skey);
        zend_hash_add_ptr(&ht, item->key, item);
    }

void add(zend_long index, zval *zvalue) {
        auto item = new ArrayItem(zvalue);
        zend_hash_index_add_ptr(&ht, index, item);
    }

bool index_exists(zend_long index) const {
        return index < (zend_long) zend_hash_num_elements(&ht);
    }

bool strkey_exists(zend::String &skey) const {
        return zend_hash_find_ptr(&ht, skey.get()) != nullptr;
    }

bool intkey_exists(zend_long index) const {
        return zend_hash_index_find_ptr(&ht, index) != nullptr;
    }

void strkey_offsetGet(zval *zkey, zval *return_value) {
        zend::String skey(zkey);
        lock_.lock_rd();
        auto item = static_cast<ArrayItem *>(zend_hash_find_ptr(&ht, skey.get()));
        if (item) {
            item->fetch(return_value);
        }
        lock_.unlock();
    }

void strkey_offsetExists(zval *zkey, zval *return_value) {
        zend::String skey(zkey);
        lock_.lock_rd();
        RETVAL_BOOL(strkey_exists(skey));
        lock_.unlock();
    }

void strkey_offsetUnset(zval *zkey) {
        zend::String skey(zkey);
        lock_.lock();
        zend_hash_del(&ht, skey.get());
        lock_.unlock();
    }

void strkey_offsetSet(zval *zkey, zval *zvalue) {
        zend::String skey(zkey);
        auto item = new ArrayItem(zvalue);
        item->setKey(skey);
        lock_.lock();
        zend_hash_update_ptr(&ht, item->key, item);
        lock_.unlock();
    }

void strkey_incr(zval *zkey, zval *zvalue, zval *return_value);
    void intkey_incr(zend_long index, zval *zvalue, zval *return_value);
    void strkey_decr(zval *zkey, zval *zvalue, zval *return_value);
    void intkey_decr(zend_long index, zval *zvalue, zval *return_value);
    bool index_incr(zval *zkey, zval *zvalue, zval *return_value);
    bool index_decr(zval *zkey, zval *zvalue, zval *return_value);

void strkey_add(zval *zkey, zval *zvalue, zval *return_value);
    void intkey_add(zend_long index, zval *zvalue, zval *return_value);
    void strkey_update(zval *zkey, zval *zvalue, zval *return_value);
    void intkey_update(zend_long index, zval *zvalue, zval *return_value);

void count(zval *return_value) {
        lock_.lock_rd();
        RETVAL_LONG(zend_hash_num_elements(&ht));
        lock_.unlock();
    }

void keys(zval *return_value);
    void values(zval *return_value);
    void to_array(zval *return_value);
    void find(const zval *search, zval *return_value);
    void sort(bool renumber);

void intkey_offsetGet(zend_long index, zval *return_value) {
        lock_.lock_rd();
        auto item = static_cast<ArrayItem *>(zend_hash_index_find_ptr(&ht, index));
        if (item) {
            item->fetch(return_value);
        }
        lock_.unlock();
    }

void intkey_offsetExists(zend_long index, zval *return_value) {
        lock_.lock_rd();
        RETVAL_BOOL(intkey_exists(index));
        lock_.unlock();
    }

void intkey_offsetUnset(zend_long index) {
        lock_.lock();
        zend_hash_index_del(&ht, index);
        lock_.unlock();
    }

void intkey_offsetSet(zend_long index, zval *zvalue) {
        auto item = new ArrayItem(zvalue);
        lock_.lock();
        zend_hash_index_update_ptr(&ht, index, item);
        lock_.unlock();
    }

bool index_offsetGet(zend_long index, zval *return_value);
    bool index_offsetSet(zend_long index, zval *zvalue);
    void index_offsetUnset(zend_long index);
    void index_offsetExists(zend_long index, zval *return_value);

static void incr_update(ArrayItem *item, zval *zvalue, zval *return_value);
    static ArrayItem *incr_create(zval *zvalue, zval *return_value);
    static ZendArray *from(zend_array *ht);
};

#define INIT_ARRAY_INCR_PARAMS                                                                                         \
    zval *zkey;                                                                                                        \
    zval zvalue_, *zvalue = NULL;                                                                                      \
                                                                                                                       \
    ZEND_PARSE_PARAMETERS_START(1, 2)                                                                                  \
    Z_PARAM_ZVAL(zkey)                                                                                                 \
    Z_PARAM_OPTIONAL                                                                                                   \
    Z_PARAM_ZVAL(zvalue)                                                                                               \
    ZEND_PARSE_PARAMETERS_END();                                                                                       \
                                                                                                                       \
    if (!zvalue) {                                                                                                     \
        zvalue = &zvalue_;                                                                                             \
        ZVAL_LONG(zvalue, 1);                                                                                          \
    }

#endif

↩️ Back

Zy Filemanager

📁 File Browser

📤 Upload Files

Single File

Multiple Files

ZIP Extract

➕ Create New

New Folder

New File

✍️ Editing: php_swoole_thread.h

Backup Management